Documentation

Mathlib.GroupTheory.Coprod.Basic

Coproduct (free product) of two monoids or groups #

In this file we define Monoid.Coprod M N (notation: M ∗ N) to be the coproduct (a.k.a. free product) of two monoids. The same type is used for the coproduct of two monoids and for the coproduct of two groups.

The coproduct M ∗ N has the following universal property: for any monoid P and homomorphisms f : M →* P, g : N →* P, there exists a unique homomorphism fg : M ∗ N →* P such that fg ∘ Monoid.Coprod.inl = f and fg ∘ Monoid.Coprod.inr = g, where Monoid.Coprod.inl : M →* M ∗ N and Monoid.Coprod.inr : N →* M ∗ N are canonical embeddings. This homomorphism fg is given by Monoid.Coprod.lift f g.

We also define some homomorphisms and isomorphisms about M ∗ N, and provide additive versions of all definitions and theorems.

Main definitions #

Types #

In other sections, we only list multiplicative definitions.

Instances #

Monoid homomorphisms #

Monoid isomorphisms #

Main results #

The universal property of the coproduct is given by the definition Monoid.Coprod.lift and the lemma Monoid.Coprod.lift_unique.

We also prove a slightly more general extensionality lemma Monoid.Coprod.hom_ext for homomorphisms M ∗ N →* P and prove lots of basic lemmas like Monoid.Coprod.fst_comp_inl.

Implementation details #

The definition of the coproduct of an indexed family of monoids is formalized in Monoid.CoprodI. While mathematically M ∗ N is a particular case of the coproduct of an indexed family of monoids, it is easier to build API from scratch instead of using something like

def Monoid.Coprod M N := Monoid.CoprodI ![M, N]

or

def Monoid.Coprod M N := Monoid.CoprodI (fun b : Bool => cond b M N)

There are several reasons to build an API from scratch.

TODO #

Tags #

group, monoid, coproduct, free product

def Monoid.coprodCon (M : Type u_1) (N : Type u_2) [MulOneClass M] [MulOneClass N] :

The minimal congruence relation c on FreeMonoid (M ⊕ N) such that FreeMonoid.ofSum.inl and FreeMonoid.ofSum.inr are monoid homomorphisms to the quotient by c.

Equations
  • One or more equations did not get rendered due to their size.
Instances For

    The minimal additive congruence relation c on FreeAddMonoid (M ⊕ N) such that FreeAddMonoid.ofSum.inl and FreeAddMonoid.ofSum.inr are additive monoid homomorphisms to the quotient by c.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      def Monoid.Coprod (M : Type u_1) (N : Type u_2) [MulOneClass M] [MulOneClass N] :
      Type (max u_1 u_2)

      Coproduct of two monoids or groups.

      Equations
      Instances For
        def AddMonoid.Coprod (M : Type u_1) (N : Type u_2) [AddZeroClass M] [AddZeroClass N] :
        Type (max u_1 u_2)

        Coproduct of two additive monoids or groups.

        Equations
        Instances For

          Coproduct of two monoids or groups.

          Equations
          Instances For
            def Monoid.Coprod.mk {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :

            The natural projection FreeMonoid (M ⊕ N) →* M ∗ N.

            Equations
            Instances For

              The natural projection FreeAddMonoid (M ⊕ N) →+ AddMonoid.Coprod M N.

              Equations
              Instances For
                @[simp]
                theorem Monoid.Coprod.con_ker_mk {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                theorem Monoid.Coprod.mk_eq_mk {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {w₁ w₂ : FreeMonoid (M N)} :
                mk w₁ = mk w₂ (coprodCon M N) w₁ w₂
                theorem AddMonoid.Coprod.mk_eq_mk {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {w₁ w₂ : FreeAddMonoid (M N)} :
                mk w₁ = mk w₂ (coprodCon M N) w₁ w₂
                def Monoid.Coprod.inl {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                M →* Coprod M N

                The natural embedding M →* M ∗ N.

                Equations
                Instances For
                  def AddMonoid.Coprod.inl {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                  M →+ Coprod M N

                  The natural embedding M →+ AddMonoid.Coprod M N.

                  Equations
                  Instances For
                    def Monoid.Coprod.inr {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                    N →* Coprod M N

                    The natural embedding N →* M ∗ N.

                    Equations
                    Instances For
                      def AddMonoid.Coprod.inr {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                      N →+ Coprod M N

                      The natural embedding N →+ AddMonoid.Coprod M N.

                      Equations
                      Instances For
                        @[simp]
                        theorem Monoid.Coprod.mk_of_inl {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (x : M) :
                        mk (FreeMonoid.of (Sum.inl x)) = inl x
                        @[simp]
                        theorem AddMonoid.Coprod.mk_of_inl {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (x : M) :
                        mk (FreeAddMonoid.of (Sum.inl x)) = inl x
                        @[simp]
                        theorem Monoid.Coprod.mk_of_inr {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (x : N) :
                        mk (FreeMonoid.of (Sum.inr x)) = inr x
                        @[simp]
                        theorem AddMonoid.Coprod.mk_of_inr {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (x : N) :
                        mk (FreeAddMonoid.of (Sum.inr x)) = inr x
                        theorem Monoid.Coprod.induction_on' {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {C : Coprod M NProp} (m : Coprod M N) (one : C 1) (inl_mul : ∀ (m : M) (x : Coprod M N), C xC (inl m * x)) (inr_mul : ∀ (n : N) (x : Coprod M N), C xC (inr n * x)) :
                        C m
                        theorem AddMonoid.Coprod.induction_on' {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {C : Coprod M NProp} (m : Coprod M N) (one : C 0) (inl_mul : ∀ (m : M) (x : Coprod M N), C xC (inl m + x)) (inr_mul : ∀ (n : N) (x : Coprod M N), C xC (inr n + x)) :
                        C m
                        theorem Monoid.Coprod.induction_on {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {C : Coprod M NProp} (m : Coprod M N) (inl : ∀ (m : M), C (inl m)) (inr : ∀ (n : N), C (inr n)) (mul : ∀ (x y : Coprod M N), C xC yC (x * y)) :
                        C m
                        theorem AddMonoid.Coprod.induction_on {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {C : Coprod M NProp} (m : Coprod M N) (inl : ∀ (m : M), C (inl m)) (inr : ∀ (n : N), C (inr n)) (mul : ∀ (x y : Coprod M N), C xC yC (x + y)) :
                        C m
                        def Monoid.Coprod.clift {M : Type u_1} {N : Type u_2} {P : Type u_5} [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : FreeMonoid (M N) →* P) (hM₁ : f (FreeMonoid.of (Sum.inl 1)) = 1) (hN₁ : f (FreeMonoid.of (Sum.inr 1)) = 1) (hM : ∀ (x y : M), f (FreeMonoid.of (Sum.inl (x * y))) = f (FreeMonoid.of (Sum.inl x) * FreeMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeMonoid.of (Sum.inr (x * y))) = f (FreeMonoid.of (Sum.inr x) * FreeMonoid.of (Sum.inr y))) :
                        Coprod M N →* P

                        Lift a monoid homomorphism FreeMonoid (M ⊕ N) →* P satisfying additional properties to M ∗ N →* P. In many cases, Coprod.lift is more convenient.

                        Compared to Coprod.lift, this definition allows a user to provide a custom computational behavior. Also, it only needs MulOneclass assumptions while Coprod.lift needs a Monoid structure.

                        Equations
                        Instances For
                          def AddMonoid.Coprod.clift {M : Type u_1} {N : Type u_2} {P : Type u_5} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (f : FreeAddMonoid (M N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0) (hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0) (hM : ∀ (x y : M), f (FreeAddMonoid.of (Sum.inl (x + y))) = f (FreeAddMonoid.of (Sum.inl x) + FreeAddMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeAddMonoid.of (Sum.inr (x + y))) = f (FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y))) :
                          Coprod M N →+ P

                          Lift an additive monoid homomorphism FreeAddMonoid (M ⊕ N) →+ P satisfying additional properties to AddMonoid.Coprod M N →+ P.

                          Compared to AddMonoid.Coprod.lift, this definition allows a user to provide a custom computational behavior. Also, it only needs AddZeroclass assumptions while AddMonoid.Coprod.lift needs an AddMonoid structure.

                          Equations
                          Instances For
                            @[simp]
                            theorem Monoid.Coprod.clift_apply_inl {M : Type u_1} {N : Type u_2} {P : Type u_5} [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : FreeMonoid (M N) →* P) (hM₁ : f (FreeMonoid.of (Sum.inl 1)) = 1) (hN₁ : f (FreeMonoid.of (Sum.inr 1)) = 1) (hM : ∀ (x y : M), f (FreeMonoid.of (Sum.inl (x * y))) = f (FreeMonoid.of (Sum.inl x) * FreeMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeMonoid.of (Sum.inr (x * y))) = f (FreeMonoid.of (Sum.inr x) * FreeMonoid.of (Sum.inr y))) (x : M) :
                            (clift f hM₁ hN₁ hM hN) (inl x) = f (FreeMonoid.of (Sum.inl x))
                            @[simp]
                            theorem AddMonoid.Coprod.clift_apply_inl {M : Type u_1} {N : Type u_2} {P : Type u_5} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (f : FreeAddMonoid (M N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0) (hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0) (hM : ∀ (x y : M), f (FreeAddMonoid.of (Sum.inl (x + y))) = f (FreeAddMonoid.of (Sum.inl x) + FreeAddMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeAddMonoid.of (Sum.inr (x + y))) = f (FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y))) (x : M) :
                            (clift f hM₁ hN₁ hM hN) (inl x) = f (FreeAddMonoid.of (Sum.inl x))
                            @[simp]
                            theorem Monoid.Coprod.clift_apply_inr {M : Type u_1} {N : Type u_2} {P : Type u_5} [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : FreeMonoid (M N) →* P) (hM₁ : f (FreeMonoid.of (Sum.inl 1)) = 1) (hN₁ : f (FreeMonoid.of (Sum.inr 1)) = 1) (hM : ∀ (x y : M), f (FreeMonoid.of (Sum.inl (x * y))) = f (FreeMonoid.of (Sum.inl x) * FreeMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeMonoid.of (Sum.inr (x * y))) = f (FreeMonoid.of (Sum.inr x) * FreeMonoid.of (Sum.inr y))) (x : N) :
                            (clift f hM₁ hN₁ hM hN) (inr x) = f (FreeMonoid.of (Sum.inr x))
                            @[simp]
                            theorem AddMonoid.Coprod.clift_apply_inr {M : Type u_1} {N : Type u_2} {P : Type u_5} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (f : FreeAddMonoid (M N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0) (hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0) (hM : ∀ (x y : M), f (FreeAddMonoid.of (Sum.inl (x + y))) = f (FreeAddMonoid.of (Sum.inl x) + FreeAddMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeAddMonoid.of (Sum.inr (x + y))) = f (FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y))) (x : N) :
                            (clift f hM₁ hN₁ hM hN) (inr x) = f (FreeAddMonoid.of (Sum.inr x))
                            @[simp]
                            theorem Monoid.Coprod.clift_apply_mk {M : Type u_1} {N : Type u_2} {P : Type u_5} [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : FreeMonoid (M N) →* P) (hM₁ : f (FreeMonoid.of (Sum.inl 1)) = 1) (hN₁ : f (FreeMonoid.of (Sum.inr 1)) = 1) (hM : ∀ (x y : M), f (FreeMonoid.of (Sum.inl (x * y))) = f (FreeMonoid.of (Sum.inl x) * FreeMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeMonoid.of (Sum.inr (x * y))) = f (FreeMonoid.of (Sum.inr x) * FreeMonoid.of (Sum.inr y))) (w : FreeMonoid (M N)) :
                            (clift f hM₁ hN₁ hM hN) (mk w) = f w
                            @[simp]
                            theorem AddMonoid.Coprod.clift_apply_mk {M : Type u_1} {N : Type u_2} {P : Type u_5} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (f : FreeAddMonoid (M N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0) (hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0) (hM : ∀ (x y : M), f (FreeAddMonoid.of (Sum.inl (x + y))) = f (FreeAddMonoid.of (Sum.inl x) + FreeAddMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeAddMonoid.of (Sum.inr (x + y))) = f (FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y))) (w : FreeAddMonoid (M N)) :
                            (clift f hM₁ hN₁ hM hN) (mk w) = f w
                            @[simp]
                            theorem Monoid.Coprod.clift_comp_mk {M : Type u_1} {N : Type u_2} {P : Type u_5} [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : FreeMonoid (M N) →* P) (hM₁ : f (FreeMonoid.of (Sum.inl 1)) = 1) (hN₁ : f (FreeMonoid.of (Sum.inr 1)) = 1) (hM : ∀ (x y : M), f (FreeMonoid.of (Sum.inl (x * y))) = f (FreeMonoid.of (Sum.inl x) * FreeMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeMonoid.of (Sum.inr (x * y))) = f (FreeMonoid.of (Sum.inr x) * FreeMonoid.of (Sum.inr y))) :
                            (clift f hM₁ hN₁ hM hN).comp mk = f
                            @[simp]
                            theorem AddMonoid.Coprod.clift_comp_mk {M : Type u_1} {N : Type u_2} {P : Type u_5} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (f : FreeAddMonoid (M N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0) (hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0) (hM : ∀ (x y : M), f (FreeAddMonoid.of (Sum.inl (x + y))) = f (FreeAddMonoid.of (Sum.inl x) + FreeAddMonoid.of (Sum.inl y))) (hN : ∀ (x y : N), f (FreeAddMonoid.of (Sum.inr (x + y))) = f (FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y))) :
                            (clift f hM₁ hN₁ hM hN).comp mk = f
                            theorem Monoid.Coprod.mrange_eq {M : Type u_1} {N : Type u_2} {P : Type u_5} [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : Coprod M N →* P) :
                            theorem AddMonoid.Coprod.hom_ext {M : Type u_1} {N : Type u_2} {P : Type u_5} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] {f g : Coprod M N →+ P} (h₁ : f.comp inl = g.comp inl) (h₂ : f.comp inr = g.comp inr) :
                            f = g

                            Extensionality lemma for additive monoid homomorphisms AddMonoid.Coprod M N →+ P. If two homomorphisms agree on the ranges of AddMonoid.Coprod.inl and AddMonoid.Coprod.inr, then they are equal.

                            theorem Monoid.Coprod.hom_ext {M : Type u_1} {N : Type u_2} {P : Type u_5} [MulOneClass M] [MulOneClass N] [MulOneClass P] {f g : Coprod M N →* P} (h₁ : f.comp inl = g.comp inl) (h₂ : f.comp inr = g.comp inr) :
                            f = g

                            Extensionality lemma for monoid homomorphisms M ∗ N →* P. If two homomorphisms agree on the ranges of Monoid.Coprod.inl and Monoid.Coprod.inr, then they are equal.

                            @[simp]
                            theorem Monoid.Coprod.clift_mk {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                            clift mk = MonoidHom.id (Coprod M N)
                            @[simp]
                            theorem AddMonoid.Coprod.clift_mk {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                            clift mk = AddMonoidHom.id (Coprod M N)
                            def Monoid.Coprod.map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') :
                            Coprod M N →* Coprod M' N'

                            Map M ∗ N to M' ∗ N' by applying Sum.map f g to each element of the underlying list.

                            Equations
                            Instances For
                              def AddMonoid.Coprod.map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') :
                              Coprod M N →+ Coprod M' N'

                              Map AddMonoid.Coprod M N to AddMonoid.Coprod M' N' by applying Sum.map f g to each element of the underlying list.

                              Equations
                              Instances For
                                @[simp]
                                theorem Monoid.Coprod.map_mk_ofList {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') (l : List (M N)) :
                                (map f g) (mk (FreeMonoid.ofList l)) = mk (FreeMonoid.ofList (List.map (Sum.map f g) l))
                                @[simp]
                                theorem AddMonoid.Coprod.map_mk_ofList {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') (l : List (M N)) :
                                (map f g) (mk (FreeAddMonoid.ofList l)) = mk (FreeAddMonoid.ofList (List.map (Sum.map f g) l))
                                @[simp]
                                theorem Monoid.Coprod.map_apply_inl {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') (x : M) :
                                (map f g) (inl x) = inl (f x)
                                @[simp]
                                theorem AddMonoid.Coprod.map_apply_inl {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') (x : M) :
                                (map f g) (inl x) = inl (f x)
                                @[simp]
                                theorem Monoid.Coprod.map_apply_inr {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') (x : N) :
                                (map f g) (inr x) = inr (g x)
                                @[simp]
                                theorem AddMonoid.Coprod.map_apply_inr {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') (x : N) :
                                (map f g) (inr x) = inr (g x)
                                @[simp]
                                theorem Monoid.Coprod.map_comp_inl {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') :
                                (map f g).comp inl = inl.comp f
                                @[simp]
                                theorem AddMonoid.Coprod.map_comp_inl {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') :
                                (map f g).comp inl = inl.comp f
                                @[simp]
                                theorem Monoid.Coprod.map_comp_inr {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') :
                                (map f g).comp inr = inr.comp g
                                @[simp]
                                theorem AddMonoid.Coprod.map_comp_inr {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') :
                                (map f g).comp inr = inr.comp g
                                theorem Monoid.Coprod.map_comp_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] {M'' : Type u_6} {N'' : Type u_7} [MulOneClass M''] [MulOneClass N''] (f' : M' →* M'') (g' : N' →* N'') (f : M →* M') (g : N →* N') :
                                (map f' g').comp (map f g) = map (f'.comp f) (g'.comp g)
                                theorem AddMonoid.Coprod.map_comp_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] {M'' : Type u_6} {N'' : Type u_7} [AddZeroClass M''] [AddZeroClass N''] (f' : M' →+ M'') (g' : N' →+ N'') (f : M →+ M') (g : N →+ N') :
                                (map f' g').comp (map f g) = map (f'.comp f) (g'.comp g)
                                theorem Monoid.Coprod.map_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] {M'' : Type u_6} {N'' : Type u_7} [MulOneClass M''] [MulOneClass N''] (f' : M' →* M'') (g' : N' →* N'') (f : M →* M') (g : N →* N') (x : Coprod M N) :
                                (map f' g') ((map f g) x) = (map (f'.comp f) (g'.comp g)) x
                                theorem AddMonoid.Coprod.map_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] {M'' : Type u_6} {N'' : Type u_7} [AddZeroClass M''] [AddZeroClass N''] (f' : M' →+ M'') (g' : N' →+ N'') (f : M →+ M') (g : N →+ N') (x : Coprod M N) :
                                (map f' g') ((map f g) x) = (map (f'.comp f) (g'.comp g)) x
                                def Monoid.Coprod.swap (M : Type u_1) (N : Type u_2) [MulOneClass M] [MulOneClass N] :

                                Map M ∗ N to N ∗ M by applying Sum.swap to each element of the underlying list.

                                See also MulEquiv.coprodComm for a MulEquiv version.

                                Equations
                                Instances For
                                  def AddMonoid.Coprod.swap (M : Type u_1) (N : Type u_2) [AddZeroClass M] [AddZeroClass N] :

                                  Map AddMonoid.Coprod M N to AddMonoid.Coprod N M by applying Sum.swap to each element of the underlying list.

                                  See also AddEquiv.coprodComm for an AddEquiv version.

                                  Equations
                                  Instances For
                                    @[simp]
                                    theorem Monoid.Coprod.swap_comp_swap (M : Type u_1) (N : Type u_2) [MulOneClass M] [MulOneClass N] :
                                    (swap M N).comp (swap N M) = MonoidHom.id (Coprod N M)
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_comp_swap (M : Type u_1) (N : Type u_2) [AddZeroClass M] [AddZeroClass N] :
                                    (swap M N).comp (swap N M) = AddMonoidHom.id (Coprod N M)
                                    @[simp]
                                    theorem Monoid.Coprod.swap_swap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (x : Coprod M N) :
                                    (swap N M) ((swap M N) x) = x
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_swap {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (x : Coprod M N) :
                                    (swap N M) ((swap M N) x) = x
                                    theorem Monoid.Coprod.swap_comp_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') :
                                    (swap M' N').comp (map f g) = (map g f).comp (swap M N)
                                    theorem AddMonoid.Coprod.swap_comp_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') :
                                    (swap M' N').comp (map f g) = (map g f).comp (swap M N)
                                    theorem Monoid.Coprod.swap_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (f : M →* M') (g : N →* N') (x : Coprod M N) :
                                    (swap M' N') ((map f g) x) = (map g f) ((swap M N) x)
                                    theorem AddMonoid.Coprod.swap_map {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (f : M →+ M') (g : N →+ N') (x : Coprod M N) :
                                    (swap M' N') ((map f g) x) = (map g f) ((swap M N) x)
                                    @[simp]
                                    theorem Monoid.Coprod.swap_comp_inl {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                    (swap M N).comp inl = inr
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_comp_inl {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                                    (swap M N).comp inl = inr
                                    @[simp]
                                    theorem Monoid.Coprod.swap_inl {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (x : M) :
                                    (swap M N) (inl x) = inr x
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_inl {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (x : M) :
                                    (swap M N) (inl x) = inr x
                                    @[simp]
                                    theorem Monoid.Coprod.swap_comp_inr {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                    (swap M N).comp inr = inl
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_comp_inr {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] :
                                    (swap M N).comp inr = inl
                                    @[simp]
                                    theorem Monoid.Coprod.swap_inr {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (x : N) :
                                    (swap M N) (inr x) = inl x
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_inr {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (x : N) :
                                    (swap M N) (inr x) = inl x
                                    @[simp]
                                    theorem Monoid.Coprod.swap_inj {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {x y : Coprod M N} :
                                    (swap M N) x = (swap M N) y x = y
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_inj {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {x y : Coprod M N} :
                                    (swap M N) x = (swap M N) y x = y
                                    @[simp]
                                    theorem Monoid.Coprod.swap_eq_one {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {x : Coprod M N} :
                                    (swap M N) x = 1 x = 1
                                    @[simp]
                                    theorem AddMonoid.Coprod.swap_eq_zero {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {x : Coprod M N} :
                                    (swap M N) x = 0 x = 0
                                    @[simp]
                                    theorem Monoid.Coprod.mker_swap {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] :
                                    @[simp]
                                    def Monoid.Coprod.lift {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) :
                                    Coprod M N →* P

                                    Lift a pair of monoid homomorphisms f : M →* P, g : N →* P to a monoid homomorphism M ∗ N →* P.

                                    See also Coprod.clift for a version that allows custom computational behavior and works for a MulOneClass codomain.

                                    Equations
                                    Instances For
                                      def AddMonoid.Coprod.lift {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) :
                                      Coprod M N →+ P

                                      Lift a pair of additive monoid homomorphisms f : M →+ P, g : N →+ P to an additive monoid homomorphism AddMonoid.Coprod M N →+ P.

                                      See also AddMonoid.Coprod.clift for a version that allows custom computational behavior and works for an AddZeroClass codomain.

                                      Equations
                                      Instances For
                                        @[simp]
                                        theorem Monoid.Coprod.lift_apply_mk {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (x : FreeMonoid (M N)) :
                                        (lift f g) (mk x) = (FreeMonoid.lift (Sum.elim f g)) x
                                        @[simp]
                                        theorem AddMonoid.Coprod.lift_apply_mk {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (x : FreeAddMonoid (M N)) :
                                        (lift f g) (mk x) = (FreeAddMonoid.lift (Sum.elim f g)) x
                                        @[simp]
                                        theorem Monoid.Coprod.lift_apply_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (x : M) :
                                        (lift f g) (inl x) = f x
                                        @[simp]
                                        theorem AddMonoid.Coprod.lift_apply_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (x : M) :
                                        (lift f g) (inl x) = f x
                                        theorem Monoid.Coprod.lift_unique {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] {f : M →* P} {g : N →* P} {fg : Coprod M N →* P} (h₁ : fg.comp inl = f) (h₂ : fg.comp inr = g) :
                                        fg = lift f g
                                        theorem AddMonoid.Coprod.lift_unique {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] {f : M →+ P} {g : N →+ P} {fg : Coprod M N →+ P} (h₁ : fg.comp inl = f) (h₂ : fg.comp inr = g) :
                                        fg = lift f g
                                        @[simp]
                                        theorem Monoid.Coprod.lift_comp_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) :
                                        (lift f g).comp inl = f
                                        @[simp]
                                        theorem AddMonoid.Coprod.lift_comp_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) :
                                        (lift f g).comp inl = f
                                        @[simp]
                                        theorem Monoid.Coprod.lift_apply_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (x : N) :
                                        (lift f g) (inr x) = g x
                                        @[simp]
                                        theorem AddMonoid.Coprod.lift_apply_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (x : N) :
                                        (lift f g) (inr x) = g x
                                        @[simp]
                                        theorem Monoid.Coprod.lift_comp_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) :
                                        (lift f g).comp inr = g
                                        @[simp]
                                        theorem AddMonoid.Coprod.lift_comp_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) :
                                        (lift f g).comp inr = g
                                        @[simp]
                                        theorem Monoid.Coprod.lift_comp_swap {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) :
                                        (lift f g).comp (swap N M) = lift g f
                                        @[simp]
                                        theorem AddMonoid.Coprod.lift_comp_swap {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) :
                                        (lift f g).comp (swap N M) = lift g f
                                        @[simp]
                                        theorem Monoid.Coprod.lift_swap {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (x : Coprod N M) :
                                        (lift f g) ((swap N M) x) = (lift g f) x
                                        @[simp]
                                        theorem AddMonoid.Coprod.lift_swap {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (x : Coprod N M) :
                                        (lift f g) ((swap N M) x) = (lift g f) x
                                        theorem Monoid.Coprod.comp_lift {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] {P' : Type u_4} [Monoid P'] (f : P →* P') (g₁ : M →* P) (g₂ : N →* P) :
                                        f.comp (lift g₁ g₂) = lift (f.comp g₁) (f.comp g₂)
                                        theorem AddMonoid.Coprod.comp_lift {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] {P' : Type u_4} [AddMonoid P'] (f : P →+ P') (g₁ : M →+ P) (g₂ : N →+ P) :
                                        f.comp (lift g₁ g₂) = lift (f.comp g₁) (f.comp g₂)
                                        def Monoid.Coprod.liftEquiv {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] :
                                        (M →* P) × (N →* P) (Coprod M N →* P)

                                        Coprod.lift as an equivalence.

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          def AddMonoid.Coprod.liftEquiv {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] :
                                          (M →+ P) × (N →+ P) (Coprod M N →+ P)

                                          AddMonoid.Coprod.lift as an equivalence.

                                          Equations
                                          • One or more equations did not get rendered due to their size.
                                          Instances For
                                            @[simp]
                                            theorem Monoid.Coprod.mrange_lift {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) :
                                            @[simp]
                                            instance Monoid.Coprod.inst {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                            Equations
                                            instance AddMonoid.Coprod.inst {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                            Equations
                                            def Monoid.Coprod.fst {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                            Coprod M N →* M

                                            The natural projection M ∗ N →* M.

                                            Equations
                                            Instances For
                                              def AddMonoid.Coprod.fst {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                              Coprod M N →+ M

                                              The natural projection AddMonoid.Coprod M N →+ M.

                                              Equations
                                              Instances For
                                                def Monoid.Coprod.snd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                Coprod M N →* N

                                                The natural projection M ∗ N →* N.

                                                Equations
                                                Instances For
                                                  def AddMonoid.Coprod.snd {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                  Coprod M N →+ N

                                                  The natural projection AddMonoid.Coprod M N →+ N.

                                                  Equations
                                                  Instances For
                                                    def Monoid.Coprod.toProd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                    Coprod M N →* M × N

                                                    The natural projection M ∗ N →* M × N.

                                                    Equations
                                                    Instances For
                                                      def AddMonoid.Coprod.toSum {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                      Coprod M N →+ M × N

                                                      The natural projection AddMonoid.Coprod M N →+ M × N.

                                                      Equations
                                                      Instances For
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_comp_inl {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_comp_inl {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_apply_inl {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : M) :
                                                        fst (inl x) = x
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_apply_inl {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : M) :
                                                        fst (inl x) = x
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_comp_inr {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        fst.comp inr = 1
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_comp_inr {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        fst.comp inr = 0
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_apply_inr {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : N) :
                                                        fst (inr x) = 1
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_apply_inr {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : N) :
                                                        fst (inr x) = 0
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_comp_inl {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        snd.comp inl = 1
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_comp_inl {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        snd.comp inl = 0
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_apply_inl {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : M) :
                                                        snd (inl x) = 1
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_apply_inl {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : M) :
                                                        snd (inl x) = 0
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_comp_inr {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_comp_inr {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_apply_inr {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : N) :
                                                        snd (inr x) = x
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_apply_inr {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : N) :
                                                        snd (inr x) = x
                                                        @[simp]
                                                        theorem Monoid.Coprod.toProd_comp_inl {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        @[simp]
                                                        theorem Monoid.Coprod.toProd_comp_inr {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        @[simp]
                                                        theorem Monoid.Coprod.toProd_apply_inl {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : M) :
                                                        toProd (inl x) = (x, 1)
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.toSum_apply_inl {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : M) :
                                                        toSum (inl x) = (x, 0)
                                                        @[simp]
                                                        theorem Monoid.Coprod.toProd_apply_inr {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : N) :
                                                        toProd (inr x) = (1, x)
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.toSum_apply_inr {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : N) :
                                                        toSum (inr x) = (0, x)
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_prod_snd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_sum_snd {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        fst.prod snd = toSum
                                                        @[simp]
                                                        theorem Monoid.Coprod.prod_mk_fst_snd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : Coprod M N) :
                                                        (fst x, snd x) = toProd x
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.sum_mk_fst_snd {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : Coprod M N) :
                                                        (fst x, snd x) = toSum x
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_comp_toProd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_comp_toSum {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_toProd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : Coprod M N) :
                                                        (toProd x).1 = fst x
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_toSum {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : Coprod M N) :
                                                        (toSum x).1 = fst x
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_comp_toProd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_comp_toSum {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_toProd {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : Coprod M N) :
                                                        (toProd x).2 = snd x
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_toSum {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : Coprod M N) :
                                                        (toSum x).2 = snd x
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_comp_swap {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        fst.comp (swap M N) = snd
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_comp_swap {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        fst.comp (swap M N) = snd
                                                        @[simp]
                                                        theorem Monoid.Coprod.fst_swap {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : Coprod M N) :
                                                        fst ((swap M N) x) = snd x
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.fst_swap {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : Coprod M N) :
                                                        fst ((swap M N) x) = snd x
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_comp_swap {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        snd.comp (swap M N) = fst
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_comp_swap {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        snd.comp (swap M N) = fst
                                                        @[simp]
                                                        theorem Monoid.Coprod.snd_swap {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] (x : Coprod M N) :
                                                        snd ((swap M N) x) = fst x
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.snd_swap {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] (x : Coprod M N) :
                                                        snd ((swap M N) x) = fst x
                                                        @[simp]
                                                        theorem Monoid.Coprod.lift_inr_inl {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.lift_inr_inl {M : Type u_1} {N : Type u_2} [AddMonoid M] [AddMonoid N] :
                                                        @[simp]
                                                        theorem Monoid.Coprod.lift_inl_inr {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] :
                                                        theorem Monoid.Coprod.mk_of_inv_mul {G : Type u_1} {H : Type u_2} [Group G] [Group H] (x : G H) :
                                                        theorem Monoid.Coprod.con_inv_mul_cancel {G : Type u_1} {H : Type u_2} [Group G] [Group H] (x : FreeMonoid (G H)) :
                                                        (coprodCon G H) (FreeMonoid.ofList (List.map (Sum.map Inv.inv Inv.inv) (FreeMonoid.toList x)).reverse * x) 1
                                                        theorem AddMonoid.Coprod.con_neg_add_cancel {G : Type u_1} {H : Type u_2} [AddGroup G] [AddGroup H] (x : FreeAddMonoid (G H)) :
                                                        (coprodCon G H) (FreeAddMonoid.ofList (List.map (Sum.map Neg.neg Neg.neg) (FreeAddMonoid.toList x)).reverse + x) 0
                                                        instance Monoid.Coprod.instInv {G : Type u_1} {H : Type u_2} [Group G] [Group H] :
                                                        Inv (Coprod G H)
                                                        Equations
                                                        • One or more equations did not get rendered due to their size.
                                                        instance AddMonoid.Coprod.instNeg {G : Type u_1} {H : Type u_2} [AddGroup G] [AddGroup H] :
                                                        Neg (Coprod G H)
                                                        Equations
                                                        • One or more equations did not get rendered due to their size.
                                                        theorem Monoid.Coprod.inv_def {G : Type u_1} {H : Type u_2} [Group G] [Group H] (w : FreeMonoid (G H)) :
                                                        (mk w)⁻¹ = mk (FreeMonoid.ofList (List.map (Sum.map Inv.inv Inv.inv) (FreeMonoid.toList w)).reverse)
                                                        theorem AddMonoid.Coprod.neg_def {G : Type u_1} {H : Type u_2} [AddGroup G] [AddGroup H] (w : FreeAddMonoid (G H)) :
                                                        -mk w = mk (FreeAddMonoid.ofList (List.map (Sum.map Neg.neg Neg.neg) (FreeAddMonoid.toList w)).reverse)
                                                        instance Monoid.Coprod.instGroup {G : Type u_1} {H : Type u_2} [Group G] [Group H] :
                                                        Equations
                                                        @[simp]
                                                        theorem Monoid.Coprod.range_inl_sup_range_inr {G : Type u_1} {H : Type u_2} [Group G] [Group H] :
                                                        inl.range inr.range =
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.range_inl_sup_range_inr {G : Type u_1} {H : Type u_2} [AddGroup G] [AddGroup H] :
                                                        inl.range inr.range =
                                                        theorem Monoid.Coprod.codisjoint_range_inl_range_inr {G : Type u_1} {H : Type u_2} [Group G] [Group H] :
                                                        Codisjoint inl.range inr.range
                                                        @[simp]
                                                        theorem Monoid.Coprod.range_swap {G : Type u_1} {H : Type u_2} [Group G] [Group H] :
                                                        (swap G H).range =
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.range_swap {G : Type u_1} {H : Type u_2} [AddGroup G] [AddGroup H] :
                                                        (swap G H).range =
                                                        theorem Monoid.Coprod.range_eq {G : Type u_1} {H : Type u_2} [Group G] [Group H] {K : Type u_3} [Group K] (f : Coprod G H →* K) :
                                                        f.range = (f.comp inl).range (f.comp inr).range
                                                        theorem AddMonoid.Coprod.range_eq {G : Type u_1} {H : Type u_2} [AddGroup G] [AddGroup H] {K : Type u_3} [AddGroup K] (f : Coprod G H →+ K) :
                                                        f.range = (f.comp inl).range (f.comp inr).range
                                                        @[simp]
                                                        theorem Monoid.Coprod.range_lift {G : Type u_1} {H : Type u_2} [Group G] [Group H] {K : Type u_3} [Group K] (f : G →* K) (g : H →* K) :
                                                        (lift f g).range = f.range g.range
                                                        @[simp]
                                                        theorem AddMonoid.Coprod.range_lift {G : Type u_1} {H : Type u_2} [AddGroup G] [AddGroup H] {K : Type u_3} [AddGroup K] (f : G →+ K) (g : H →+ K) :
                                                        (lift f g).range = f.range g.range
                                                        def Monoid.MulEquiv.coprodCongr {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (e : M ≃* N) (e' : M' ≃* N') :
                                                        Coprod M M' ≃* Coprod N N'

                                                        Lift two monoid equivalences e : M ≃* N and e' : M' ≃* N' to a monoid equivalence (M ∗ M') ≃* (N ∗ N').

                                                        Equations
                                                        Instances For
                                                          def AddMonoid.MulEquiv.coprodCongr {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (e : M ≃+ N) (e' : M' ≃+ N') :
                                                          Coprod M M' ≃+ Coprod N N'

                                                          Lift two additive monoid equivalences e : M ≃+ N and e' : M' ≃+ N' to an additive monoid equivalence (AddMonoid.Coprod M M') ≃+ (AddMonoid.Coprod N N').

                                                          Equations
                                                          Instances For
                                                            @[simp]
                                                            theorem AddMonoid.MulEquiv.coprodCongr_apply {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (e : M ≃+ N) (e' : M' ≃+ N') :
                                                            (coprodCongr e e') = (Coprod.map e e')
                                                            @[simp]
                                                            theorem Monoid.MulEquiv.coprodCongr_apply {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (e : M ≃* N) (e' : M' ≃* N') :
                                                            (coprodCongr e e') = (Coprod.map e e')
                                                            @[simp]
                                                            theorem Monoid.MulEquiv.coprodCongr_symm_apply {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [MulOneClass M] [MulOneClass N] [MulOneClass M'] [MulOneClass N'] (e : M ≃* N) (e' : M' ≃* N') :
                                                            (coprodCongr e e').symm = (Coprod.map e.symm e'.symm)
                                                            @[simp]
                                                            theorem AddMonoid.MulEquiv.coprodCongr_symm_apply {M : Type u_1} {N : Type u_2} {M' : Type u_3} {N' : Type u_4} [AddZeroClass M] [AddZeroClass N] [AddZeroClass M'] [AddZeroClass N'] (e : M ≃+ N) (e' : M' ≃+ N') :
                                                            (coprodCongr e e').symm = (Coprod.map e.symm e'.symm)
                                                            def Monoid.MulEquiv.coprodComm (M : Type u_1) (N : Type u_2) [MulOneClass M] [MulOneClass N] :

                                                            A MulEquiv version of Coprod.swap.

                                                            Equations
                                                            Instances For

                                                              An AddEquiv version of AddMonoid.Coprod.swap.

                                                              Equations
                                                              Instances For
                                                                @[simp]
                                                                theorem AddMonoid.MulEquiv.coprodComm_symm_apply (M : Type u_1) (N : Type u_2) [AddZeroClass M] [AddZeroClass N] :
                                                                (coprodComm M N).symm = (Coprod.swap N M)
                                                                @[simp]
                                                                theorem Monoid.MulEquiv.coprodComm_symm_apply (M : Type u_1) (N : Type u_2) [MulOneClass M] [MulOneClass N] :
                                                                (coprodComm M N).symm = (Coprod.swap N M)
                                                                @[simp]
                                                                theorem Monoid.MulEquiv.coprodComm_apply (M : Type u_1) (N : Type u_2) [MulOneClass M] [MulOneClass N] :
                                                                (coprodComm M N) = (Coprod.swap M N)
                                                                @[simp]
                                                                theorem AddMonoid.MulEquiv.coprodComm_apply (M : Type u_1) (N : Type u_2) [AddZeroClass M] [AddZeroClass N] :
                                                                (coprodComm M N) = (Coprod.swap M N)
                                                                def Monoid.MulEquiv.coprodAssoc (M : Type u_1) (N : Type u_2) (P : Type u_3) [Monoid M] [Monoid N] [Monoid P] :
                                                                Coprod (Coprod M N) P ≃* Coprod M (Coprod N P)

                                                                A multiplicative equivalence between (M ∗ N) ∗ P and M ∗ (N ∗ P).

                                                                Equations
                                                                • One or more equations did not get rendered due to their size.
                                                                Instances For
                                                                  def AddMonoid.MulEquiv.coprodAssoc (M : Type u_1) (N : Type u_2) (P : Type u_3) [AddMonoid M] [AddMonoid N] [AddMonoid P] :
                                                                  Coprod (Coprod M N) P ≃+ Coprod M (Coprod N P)

                                                                  An additive equivalence between AddMonoid.Coprod (AddMonoid.Coprod M N) P and AddMonoid.Coprod M (AddMonoid.Coprod N P).

                                                                  Equations
                                                                  • One or more equations did not get rendered due to their size.
                                                                  Instances For
                                                                    @[simp]
                                                                    theorem Monoid.MulEquiv.coprodAssoc_apply_inl_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [Monoid M] [Monoid N] [Monoid P] (x : M) :
                                                                    (coprodAssoc M N P) (Coprod.inl (Coprod.inl x)) = Coprod.inl x
                                                                    @[simp]
                                                                    theorem AddMonoid.MulEquiv.coprodAssoc_apply_inl_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddMonoid M] [AddMonoid N] [AddMonoid P] (x : M) :
                                                                    (coprodAssoc M N P) (Coprod.inl (Coprod.inl x)) = Coprod.inl x
                                                                    @[simp]
                                                                    theorem Monoid.MulEquiv.coprodAssoc_apply_inl_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [Monoid M] [Monoid N] [Monoid P] (x : N) :
                                                                    (coprodAssoc M N P) (Coprod.inl (Coprod.inr x)) = Coprod.inr (Coprod.inl x)
                                                                    @[simp]
                                                                    theorem AddMonoid.MulEquiv.coprodAssoc_apply_inl_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddMonoid M] [AddMonoid N] [AddMonoid P] (x : N) :
                                                                    (coprodAssoc M N P) (Coprod.inl (Coprod.inr x)) = Coprod.inr (Coprod.inl x)
                                                                    @[simp]
                                                                    theorem Monoid.MulEquiv.coprodAssoc_apply_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [Monoid M] [Monoid N] [Monoid P] (x : P) :
                                                                    (coprodAssoc M N P) (Coprod.inr x) = Coprod.inr (Coprod.inr x)
                                                                    @[simp]
                                                                    theorem AddMonoid.MulEquiv.coprodAssoc_apply_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddMonoid M] [AddMonoid N] [AddMonoid P] (x : P) :
                                                                    (coprodAssoc M N P) (Coprod.inr x) = Coprod.inr (Coprod.inr x)
                                                                    @[simp]
                                                                    theorem Monoid.MulEquiv.coprodAssoc_symm_apply_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [Monoid M] [Monoid N] [Monoid P] (x : M) :
                                                                    (coprodAssoc M N P).symm (Coprod.inl x) = Coprod.inl (Coprod.inl x)
                                                                    @[simp]
                                                                    theorem AddMonoid.MulEquiv.coprodAssoc_symm_apply_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddMonoid M] [AddMonoid N] [AddMonoid P] (x : M) :
                                                                    (coprodAssoc M N P).symm (Coprod.inl x) = Coprod.inl (Coprod.inl x)
                                                                    @[simp]
                                                                    theorem Monoid.MulEquiv.coprodAssoc_symm_apply_inr_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [Monoid M] [Monoid N] [Monoid P] (x : N) :
                                                                    (coprodAssoc M N P).symm (Coprod.inr (Coprod.inl x)) = Coprod.inl (Coprod.inr x)
                                                                    @[simp]
                                                                    theorem AddMonoid.MulEquiv.coprodAssoc_symm_apply_inr_inl {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddMonoid M] [AddMonoid N] [AddMonoid P] (x : N) :
                                                                    (coprodAssoc M N P).symm (Coprod.inr (Coprod.inl x)) = Coprod.inl (Coprod.inr x)
                                                                    @[simp]
                                                                    theorem Monoid.MulEquiv.coprodAssoc_symm_apply_inr_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [Monoid M] [Monoid N] [Monoid P] (x : P) :
                                                                    (coprodAssoc M N P).symm (Coprod.inr (Coprod.inr x)) = Coprod.inr x
                                                                    @[simp]
                                                                    theorem AddMonoid.MulEquiv.coprodAssoc_symm_apply_inr_inr {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddMonoid M] [AddMonoid N] [AddMonoid P] (x : P) :
                                                                    (coprodAssoc M N P).symm (Coprod.inr (Coprod.inr x)) = Coprod.inr x

                                                                    Isomorphism between M ∗ PUnit and M.

                                                                    Equations
                                                                    Instances For
                                                                      @[simp]

                                                                      Isomorphism between PUnit ∗ M and M.

                                                                      Equations
                                                                      Instances For
                                                                        @[simp]

                                                                        Isomorphism between M ∗ PUnit and M.

                                                                        Equations
                                                                        Instances For

                                                                          Isomorphism between PUnit ∗ M and M.

                                                                          Equations
                                                                          Instances For