Documentation

Mathlib.Algebra.Group.WithOne.Basic

More operations on WithOne and WithZero #

This file defines various bundled morphisms on WithOne and WithZero that were not available in Algebra/Group/WithOne/Defs.

Main definitions #

source
instance WithZero.involutiveNeg {α : Type u} [InvolutiveNeg α] :
InvolutiveNeg (WithZero α)
Equations
source
instance WithOne.involutiveInv {α : Type u} [InvolutiveInv α] :
InvolutiveInv (WithOne α)
Equations
source
def WithZero.coeAddHom {α : Type u} [Add α] :
AddHom α (WithZero α)

WithZero.coe as a bundled morphism

Equations
  • WithZero.coeAddHom = { toFun := WithZero.coe, map_add' := ⋯ }
Instances For
    source
    @[simp]
    theorem WithZero.coeAddHom_apply {α : Type u} [Add α] :
    ∀ (a : α), WithZero.coeAddHom a = ↑a
    source
    @[simp]
    theorem WithOne.coeMulHom_apply {α : Type u} [Mul α] :
    ∀ (a : α), WithOne.coeMulHom a = ↑a
    source
    def WithOne.coeMulHom {α : Type u} [Mul α] :
    α →ₙ* WithOne α

    WithOne.coe as a bundled morphism

    Equations
    • WithOne.coeMulHom = { toFun := WithOne.coe, map_mul' := ⋯ }
    Instances For
      source
      def WithZero.lift {α : Type u} {β : Type v} [Add α] [AddZeroClass β] :
      AddHom α β ≃ (WithZero α →+ β)

      Lift an add semigroup homomorphism f to a bundled add monoid homomorphism.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        source
        def WithOne.lift {α : Type u} {β : Type v} [Mul α] [MulOneClass β] :
        (α →ₙ* β) ≃ (WithOne α →* β)

        Lift a semigroup homomorphism f to a bundled monoid homomorphism.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          source
          @[simp]
          theorem WithZero.lift_coe {α : Type u} {β : Type v} [Add α] [AddZeroClass β] (f : AddHom α β) (x : α) :
          (WithZero.lift f) ↑x = f x
          source
          @[simp]
          theorem WithOne.lift_coe {α : Type u} {β : Type v} [Mul α] [MulOneClass β] (f : α →ₙ* β) (x : α) :
          (WithOne.lift f) ↑x = f x
          source
          theorem WithZero.lift_zero {α : Type u} {β : Type v} [Add α] [AddZeroClass β] (f : AddHom α β) :
          (WithZero.lift f) 0 = 0
          source
          theorem WithOne.lift_one {α : Type u} {β : Type v} [Mul α] [MulOneClass β] (f : α →ₙ* β) :
          (WithOne.lift f) 1 = 1
          source
          theorem WithZero.lift_unique {α : Type u} {β : Type v} [Add α] [AddZeroClass β] (f : WithZero α →+ β) :
          f = WithZero.lift ((↑f).comp WithZero.coeAddHom)
          source
          theorem WithOne.lift_unique {α : Type u} {β : Type v} [Mul α] [MulOneClass β] (f : WithOne α →* β) :
          f = WithOne.lift ((↑f).comp WithOne.coeMulHom)
          source
          def WithZero.map {α : Type u} {β : Type v} [Add α] [Add β] (f : AddHom α β) :
          WithZero α →+ WithZero β

          Given an additive map from α → β returns an add monoid homomorphism from WithZero α to WithZero β

          Equations
          Instances For
            source
            def WithOne.map {α : Type u} {β : Type v} [Mul α] [Mul β] (f : α →ₙ* β) :
            WithOne α →* WithOne β

            Given a multiplicative map from α → β returns a monoid homomorphism from WithOne α to WithOne β

            Equations
            Instances For
              source
              @[simp]
              theorem WithZero.map_coe {α : Type u} {β : Type v} [Add α] [Add β] (f : AddHom α β) (a : α) :
              (WithZero.map f) ↑a = ↑(f a)
              source
              @[simp]
              theorem WithOne.map_coe {α : Type u} {β : Type v} [Mul α] [Mul β] (f : α →ₙ* β) (a : α) :
              (WithOne.map f) ↑a = ↑(f a)
              source
              @[simp]
              theorem WithZero.map_id {α : Type u} [Add α] :
              WithZero.map (AddHom.id α) = AddMonoidHom.id (WithZero α)
              source
              @[simp]
              theorem WithOne.map_id {α : Type u} [Mul α] :
              WithOne.map (MulHom.id α) = MonoidHom.id (WithOne α)
              source
              theorem WithZero.map_map {α : Type u} {β : Type v} {γ : Type w} [Add α] [Add β] [Add γ] (f : AddHom α β) (g : AddHom β γ) (x : WithZero α) :
              (WithZero.map g) ((WithZero.map f) x) = (WithZero.map (g.comp f)) x
              source
              theorem WithOne.map_map {α : Type u} {β : Type v} {γ : Type w} [Mul α] [Mul β] [Mul γ] (f : α →ₙ* β) (g : β →ₙ* γ) (x : WithOne α) :
              (WithOne.map g) ((WithOne.map f) x) = (WithOne.map (g.comp f)) x
              source
              @[simp]
              theorem WithZero.map_comp {α : Type u} {β : Type v} {γ : Type w} [Add α] [Add β] [Add γ] (f : AddHom α β) (g : AddHom β γ) :
              WithZero.map (g.comp f) = (WithZero.map g).comp (WithZero.map f)
              source
              @[simp]
              theorem WithOne.map_comp {α : Type u} {β : Type v} {γ : Type w} [Mul α] [Mul β] [Mul γ] (f : α →ₙ* β) (g : β →ₙ* γ) :
              WithOne.map (g.comp f) = (WithOne.map g).comp (WithOne.map f)
              source
              def AddEquiv.withZeroCongr {α : Type u} {β : Type v} [Add α] [Add β] (e : α ≃+ β) :
              WithZero α ≃+ WithZero β

              A version of Equiv.optionCongr for WithZero.

              Equations
              • e.withZeroCongr = { toFun := ⇑(WithZero.map e.toAddHom), invFun := ⇑(WithZero.map e.symm.toAddHom), left_inv := ⋯, right_inv := ⋯, map_add' := ⋯ }
              Instances For
                source
                @[simp]
                theorem AddEquiv.withZeroCongr_apply {α : Type u} {β : Type v} [Add α] [Add β] (e : α ≃+ β) (a : WithZero α) :
                e.withZeroCongr a = (WithZero.map e.toAddHom) a
                source
                @[simp]
                theorem MulEquiv.withOneCongr_apply {α : Type u} {β : Type v} [Mul α] [Mul β] (e : α ≃* β) (a : WithOne α) :
                e.withOneCongr a = (WithOne.map e.toMulHom) a
                source
                def MulEquiv.withOneCongr {α : Type u} {β : Type v} [Mul α] [Mul β] (e : α ≃* β) :
                WithOne α ≃* WithOne β

                A version of Equiv.optionCongr for WithOne.

                Equations
                • e.withOneCongr = { toFun := ⇑(WithOne.map e.toMulHom), invFun := ⇑(WithOne.map e.symm.toMulHom), left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯ }
                Instances For
                  source
                  @[simp]
                  theorem AddEquiv.withZeroCongr_refl {α : Type u} [Add α] :
                  (AddEquiv.refl α).withZeroCongr = AddEquiv.refl (WithZero α)
                  source
                  @[simp]
                  theorem MulEquiv.withOneCongr_refl {α : Type u} [Mul α] :
                  (MulEquiv.refl α).withOneCongr = MulEquiv.refl (WithOne α)
                  source
                  @[simp]
                  theorem AddEquiv.withZeroCongr_symm {α : Type u} {β : Type v} [Add α] [Add β] (e : α ≃+ β) :
                  e.withZeroCongr.symm = e.symm.withZeroCongr
                  source
                  @[simp]
                  theorem MulEquiv.withOneCongr_symm {α : Type u} {β : Type v} [Mul α] [Mul β] (e : α ≃* β) :
                  e.withOneCongr.symm = e.symm.withOneCongr
                  source
                  @[simp]
                  theorem AddEquiv.withZeroCongr_trans {α : Type u} {β : Type v} {γ : Type w} [Add α] [Add β] [Add γ] (e₁ : α ≃+ β) (e₂ : β ≃+ γ) :
                  e₁.withZeroCongr.trans e₂.withZeroCongr = (e₁.trans e₂).withZeroCongr
                  source
                  @[simp]
                  theorem MulEquiv.withOneCongr_trans {α : Type u} {β : Type v} {γ : Type w} [Mul α] [Mul β] [Mul γ] (e₁ : α ≃* β) (e₂ : β ≃* γ) :
                  e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr