File: Mathlib/GroupTheory/Coprod/Basic.lean

full_name: Monoid.coprodCon
code: /-- The minimal congruence relation `c` on `FreeMonoid (M ⊕ N)`
such that `FreeMonoid.of ∘ Sum.inl` and `FreeMonoid.of ∘ Sum.inr` are monoid homomorphisms
to the quotient by `c`. -/
@[to_additive "The minimal additive congruence relation `c` on `FreeAddMonoid (M ⊕ N)`
such that `FreeAddMonoid.of ∘ Sum.inl` and `FreeAddMonoid.of ∘ Sum.inr`
are additive monoid homomorphisms to the quotient by `c`."]
def coprodCon (M N : Type*) [MulOneClass M] [MulOneClass N] : Con (FreeMonoid (M ⊕ N)) 
goal: Con (FreeMonoid (M ⊕ N))

full_name: AddMonoid.coprodCon
code: /-- The minimal congruence relation `c` on `FreeMonoid (M ⊕ N)`
such that `FreeMonoid.of ∘ Sum.inl` and `FreeMonoid.of ∘ Sum.inr` are monoid homomorphisms
to the quotient by `c`. -/
@[to_additive "The minimal additive congruence relation `c` on `FreeAddMonoid (M ⊕ N)`
such that `FreeAddMonoid.of ∘ Sum.inl` and `FreeAddMonoid.of ∘ Sum.inr`
are additive monoid homomorphisms to the quotient by `c`."]
def coprodCon (M N : Type*) [MulOneClass M] [MulOneClass N] : Con (FreeMonoid (M ⊕ N)) 
goal: AddCon (FreeAddMonoid (M ⊕ N))

full_name: Monoid.Coprod
code: /-- Coproduct of two monoids or groups. -/
@[to_additive "Coproduct of two additive monoids or groups."]
def Coprod (M N : Type*) [MulOneClass M] [MulOneClass N] 
goal: Type (max u_1 u_2)

full_name: AddMonoid.Coprod
code: /-- Coproduct of two monoids or groups. -/
@[to_additive "Coproduct of two additive monoids or groups."]
def Coprod (M N : Type*) [MulOneClass M] [MulOneClass N] 
goal: Type (max u_1 u_2)

full_name: Monoid.Coprod._aux_Mathlib_GroupTheory_Coprod_Basic___unexpand_Monoid_Coprod_1
code: @[inherit_doc]
scoped infix:30 " ∗ " => Coprod
goal: Lean.PrettyPrinter.Unexpander

full_name: Monoid.Coprod.«_aux_Mathlib_GroupTheory_Coprod_Basic___macroRules_Monoid_Coprod_term_∗__1»
code: @[inherit_doc]
scoped infix:30 " ∗ " => Coprod
goal: Lean.Macro

full_name: AddMonoid.Coprod.instAddZeroClass
code: @[to_additive] protected instance : MulOneClass (M ∗ N) 
goal: AddZeroClass (AddMonoid.Coprod M N)

full_name: Monoid.Coprod.instMulOneClass
code: @[to_additive] protected instance : MulOneClass (M ∗ N) 
goal: MulOneClass (Monoid.Coprod M N)

full_name: Monoid.Coprod.mk
code: /-- The natural projection `FreeMonoid (M ⊕ N) →* M ∗ N`. -/
@[to_additive "The natural projection `FreeAddMonoid (M ⊕ N) →+ AddMonoid.Coprod M N`."]
def mk : FreeMonoid (M ⊕ N) →* M ∗ N 
goal: FreeMonoid (M ⊕ N) →* Monoid.Coprod M N

full_name: AddMonoid.Coprod.mk
code: /-- The natural projection `FreeMonoid (M ⊕ N) →* M ∗ N`. -/
@[to_additive "The natural projection `FreeAddMonoid (M ⊕ N) →+ AddMonoid.Coprod M N`."]
def mk : FreeMonoid (M ⊕ N) →* M ∗ N 
goal: FreeAddMonoid (M ⊕ N) →+ AddMonoid.Coprod M N

full_name: Monoid.Coprod.con_ker_mk
code: @[to_additive (attr := simp)]
theorem con_ker_mk : Con.ker mk = coprodCon M N 
goal: Con.ker Monoid.Coprod.mk = Monoid.coprodCon M N

full_name: AddMonoid.Coprod.con_ker_mk
code: @[to_additive (attr := simp)]
theorem con_ker_mk : Con.ker mk = coprodCon M N 
goal: AddCon.ker AddMonoid.Coprod.mk = AddMonoid.coprodCon M N

full_name: Monoid.Coprod.mk_surjective
code: @[to_additive]
theorem mk_surjective : Surjective (@mk M N _ _) 
goal: Function.Surjective ⇑Monoid.Coprod.mk

full_name: AddMonoid.Coprod.mk_surjective
code: @[to_additive]
theorem mk_surjective : Surjective (@mk M N _ _) 
goal: Function.Surjective ⇑AddMonoid.Coprod.mk

full_name: AddMonoid.Coprod.mrange_mk
code: @[to_additive (attr := simp)]
theorem mrange_mk : MonoidHom.mrange (@mk M N _ _) = ⊤ 
goal: AddMonoidHom.mrange AddMonoid.Coprod.mk = ⊤

full_name: Monoid.Coprod.mrange_mk
code: @[to_additive (attr := simp)]
theorem mrange_mk : MonoidHom.mrange (@mk M N _ _) = ⊤ 
goal: MonoidHom.mrange Monoid.Coprod.mk = ⊤

full_name: Monoid.Coprod.mk_eq_mk
code: @[to_additive]
theorem mk_eq_mk {w₁ w₂ : FreeMonoid (M ⊕ N)} : mk w₁ = mk w₂ ↔ coprodCon M N w₁ w₂ 
goal: Monoid.Coprod.mk w₁ = Monoid.Coprod.mk w₂ ↔ (Monoid.coprodCon M N) w₁ w₂

full_name: AddMonoid.Coprod.mk_eq_mk
code: @[to_additive]
theorem mk_eq_mk {w₁ w₂ : FreeMonoid (M ⊕ N)} : mk w₁ = mk w₂ ↔ coprodCon M N w₁ w₂ 
goal: AddMonoid.Coprod.mk w₁ = AddMonoid.Coprod.mk w₂ ↔ (AddMonoid.coprodCon M N) w₁ w₂

full_name: Monoid.Coprod.inl
code: /-- The natural embedding `M →* M ∗ N`. -/
@[to_additive "The natural embedding `M →+ AddMonoid.Coprod M N`."]
def inl : M →* M ∗ N 
goal: M →* Monoid.Coprod M N

full_name: AddMonoid.Coprod.inl
code: /-- The natural embedding `M →* M ∗ N`. -/
@[to_additive "The natural embedding `M →+ AddMonoid.Coprod M N`."]
def inl : M →* M ∗ N 
goal: M →+ AddMonoid.Coprod M N

full_name: AddMonoid.Coprod.inr
code: /-- The natural embedding `N →* M ∗ N`. -/
@[to_additive "The natural embedding `N →+ AddMonoid.Coprod M N`."]
def inr : N →* M ∗ N 
goal: N →+ AddMonoid.Coprod M N

full_name: Monoid.Coprod.inr
code: /-- The natural embedding `N →* M ∗ N`. -/
@[to_additive "The natural embedding `N →+ AddMonoid.Coprod M N`."]
def inr : N →* M ∗ N 
goal: N →* Monoid.Coprod M N

full_name: AddMonoid.Coprod.mk_of_inl
code: @[to_additive (attr := simp)]
theorem mk_of_inl (x : M) : (mk (of (.inl x)) : M ∗ N) = inl x 
goal: AddMonoid.Coprod.mk (FreeAddMonoid.of (Sum.inl x)) = AddMonoid.Coprod.inl x

full_name: Monoid.Coprod.mk_of_inl
code: @[to_additive (attr := simp)]
theorem mk_of_inl (x : M) : (mk (of (.inl x)) : M ∗ N) = inl x 
goal: Monoid.Coprod.mk (FreeMonoid.of (Sum.inl x)) = Monoid.Coprod.inl x

full_name: Monoid.Coprod.mk_of_inr
code: @[to_additive (attr := simp)]
theorem mk_of_inr (x : N) : (mk (of (.inr x)) : M ∗ N) = inr x 
goal: Monoid.Coprod.mk (FreeMonoid.of (Sum.inr x)) = Monoid.Coprod.inr x

full_name: AddMonoid.Coprod.mk_of_inr
code: @[to_additive (attr := simp)]
theorem mk_of_inr (x : N) : (mk (of (.inr x)) : M ∗ N) = inr x 
goal: AddMonoid.Coprod.mk (FreeAddMonoid.of (Sum.inr x)) = AddMonoid.Coprod.inr x

full_name: AddMonoid.Coprod.induction_on'
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on' {C : M ∗ N → Prop} (m : M ∗ N)
    (one : C 1)
    (inl_mul : ∀ m x, C x → C (inl m * x))
    (inr_mul : ∀ n x, C x → C (inr n * x)) : C m 
goal: C m

full_name: Monoid.Coprod.induction_on'
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on' {C : M ∗ N → Prop} (m : M ∗ N)
    (one : C 1)
    (inl_mul : ∀ m x, C x → C (inl m * x))
    (inr_mul : ∀ n x, C x → C (inr n * x)) : C m 
goal: C m

full_name: AddMonoid.Coprod.induction_on
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on {C : M ∗ N → Prop} (m : M ∗ N)
    (inl : ∀ m, C (inl m)) (inr : ∀ n, C (inr n)) (mul : ∀ x y, C x → C y → C (x * y)) : C m 
goal: C m

full_name: Monoid.Coprod.induction_on
code: @[to_additive (attr := elab_as_elim)]
theorem induction_on {C : M ∗ N → Prop} (m : M ∗ N)
    (inl : ∀ m, C (inl m)) (inr : ∀ n, C (inr n)) (mul : ∀ x y, C x → C y → C (x * y)) : C m 
goal: C m

full_name: Monoid.Coprod.clift
code: /-- 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.
-/
@[to_additive "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. "]
def clift (f : FreeMonoid (M ⊕ N) →* P)
    (hM₁ : f (of (.inl 1)) = 1) (hN₁ : f (of (.inr 1)) = 1)
    (hM : ∀ x y, f (of (.inl (x * y))) = f (of (.inl x) * of (.inl y)))
    (hN : ∀ x y, f (of (.inr (x * y))) = f (of (.inr x) * of (.inr y))) :
    M ∗ N →* P 
goal: Monoid.Coprod M N →* P

full_name: AddMonoid.Coprod.clift
code: /-- 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.
-/
@[to_additive "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. "]
def clift (f : FreeMonoid (M ⊕ N) →* P)
    (hM₁ : f (of (.inl 1)) = 1) (hN₁ : f (of (.inr 1)) = 1)
    (hM : ∀ x y, f (of (.inl (x * y))) = f (of (.inl x) * of (.inl y)))
    (hN : ∀ x y, f (of (.inr (x * y))) = f (of (.inr x) * of (.inr y))) :
    M ∗ N →* P 
goal: AddMonoid.Coprod M N →+ P

full_name: Monoid.Coprod.clift_apply_inl
code: @[to_additive (attr := simp)]
theorem clift_apply_inl (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN) (x : M) :
    clift f hM₁ hN₁ hM hN (inl x) = f (of (.inl x)) 
goal: (Monoid.Coprod.clift f hM₁ hN₁ hM hN) (Monoid.Coprod.inl x) = f (FreeMonoid.of (Sum.inl x))

full_name: AddMonoid.Coprod.clift_apply_inl
code: @[to_additive (attr := simp)]
theorem clift_apply_inl (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN) (x : M) :
    clift f hM₁ hN₁ hM hN (inl x) = f (of (.inl x)) 
goal: (AddMonoid.Coprod.clift f hM₁ hN₁ hM hN) (AddMonoid.Coprod.inl x) = f (FreeAddMonoid.of (Sum.inl x))

full_name: AddMonoid.Coprod.clift_apply_inr
code: @[to_additive (attr := simp)]
theorem clift_apply_inr (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN) (x : N) :
    clift f hM₁ hN₁ hM hN (inr x) = f (of (.inr x)) 
goal: (AddMonoid.Coprod.clift f hM₁ hN₁ hM hN) (AddMonoid.Coprod.inr x) = f (FreeAddMonoid.of (Sum.inr x))

full_name: Monoid.Coprod.clift_apply_inr
code: @[to_additive (attr := simp)]
theorem clift_apply_inr (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN) (x : N) :
    clift f hM₁ hN₁ hM hN (inr x) = f (of (.inr x)) 
goal: (Monoid.Coprod.clift f hM₁ hN₁ hM hN) (Monoid.Coprod.inr x) = f (FreeMonoid.of (Sum.inr x))

full_name: Monoid.Coprod.clift_apply_mk
code: @[to_additive (attr := simp)]
theorem clift_apply_mk (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN w) :
    clift f hM₁ hN₁ hM hN (mk w) = f w 
goal: (Monoid.Coprod.clift f hM₁ hN₁ hM hN) (Monoid.Coprod.mk w) = f w

full_name: AddMonoid.Coprod.clift_apply_mk
code: @[to_additive (attr := simp)]
theorem clift_apply_mk (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN w) :
    clift f hM₁ hN₁ hM hN (mk w) = f w 
goal: (AddMonoid.Coprod.clift f hM₁ hN₁ hM hN) (AddMonoid.Coprod.mk w) = f w

full_name: Monoid.Coprod.clift_comp_mk
code: @[to_additive (attr := simp)]
theorem clift_comp_mk (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN) :
    (clift f hM₁ hN₁ hM hN).comp mk = f 
goal: (Monoid.Coprod.clift f hM₁ hN₁ hM hN).comp Monoid.Coprod.mk = f

full_name: AddMonoid.Coprod.clift_comp_mk
code: @[to_additive (attr := simp)]
theorem clift_comp_mk (f : FreeMonoid (M ⊕ N) →* P) (hM₁ hN₁ hM hN) :
    (clift f hM₁ hN₁ hM hN).comp mk = f 
goal: (AddMonoid.Coprod.clift f hM₁ hN₁ hM hN).comp AddMonoid.Coprod.mk = f

full_name: Monoid.Coprod.mclosure_range_inl_union_inr
code: @[to_additive (attr := simp)]
theorem mclosure_range_inl_union_inr :
    Submonoid.closure (range (inl : M →* M ∗ N) ∪ range (inr : N →* M ∗ N)) = ⊤ 
goal: Submonoid.closure (Set.range ⇑Monoid.Coprod.inl ∪ Set.range ⇑Monoid.Coprod.inr) = ⊤

full_name: AddMonoid.Coprod.mclosure_range_inl_union_inr
code: @[to_additive (attr := simp)]
theorem mclosure_range_inl_union_inr :
    Submonoid.closure (range (inl : M →* M ∗ N) ∪ range (inr : N →* M ∗ N)) = ⊤ 
goal: AddSubmonoid.closure (Set.range ⇑AddMonoid.Coprod.inl ∪ Set.range ⇑AddMonoid.Coprod.inr) = ⊤

full_name: Monoid.Coprod.mrange_inl_sup_mrange_inr
code: @[to_additive (attr := simp)] theorem mrange_inl_sup_mrange_inr :
    MonoidHom.mrange (inl : M →* M ∗ N) ⊔ MonoidHom.mrange (inr : N →* M ∗ N) = ⊤ 
goal: MonoidHom.mrange Monoid.Coprod.inl ⊔ MonoidHom.mrange Monoid.Coprod.inr = ⊤

full_name: AddMonoid.Coprod.mrange_inl_sup_mrange_inr
code: @[to_additive (attr := simp)] theorem mrange_inl_sup_mrange_inr :
    MonoidHom.mrange (inl : M →* M ∗ N) ⊔ MonoidHom.mrange (inr : N →* M ∗ N) = ⊤ 
goal: AddMonoidHom.mrange AddMonoid.Coprod.inl ⊔ AddMonoidHom.mrange AddMonoid.Coprod.inr = ⊤

full_name: AddMonoid.Coprod.codisjoint_mrange_inl_mrange_inr
code: @[to_additive]
theorem codisjoint_mrange_inl_mrange_inr :
    Codisjoint (MonoidHom.mrange (inl : M →* M ∗ N)) (MonoidHom.mrange inr) 
goal: Codisjoint (AddMonoidHom.mrange AddMonoid.Coprod.inl) (AddMonoidHom.mrange AddMonoid.Coprod.inr)

full_name: Monoid.Coprod.codisjoint_mrange_inl_mrange_inr
code: @[to_additive]
theorem codisjoint_mrange_inl_mrange_inr :
    Codisjoint (MonoidHom.mrange (inl : M →* M ∗ N)) (MonoidHom.mrange inr) 
goal: Codisjoint (MonoidHom.mrange Monoid.Coprod.inl) (MonoidHom.mrange Monoid.Coprod.inr)

full_name: Monoid.Coprod.mrange_eq
code: @[to_additive] theorem mrange_eq (f : M ∗ N →* P) :
    MonoidHom.mrange f = MonoidHom.mrange (f.comp inl) ⊔ MonoidHom.mrange (f.comp inr) 
goal: MonoidHom.mrange f = MonoidHom.mrange (f.comp Monoid.Coprod.inl) ⊔ MonoidHom.mrange (f.comp Monoid.Coprod.inr)

full_name: AddMonoid.Coprod.mrange_eq
code: @[to_additive] theorem mrange_eq (f : M ∗ N →* P) :
    MonoidHom.mrange f = MonoidHom.mrange (f.comp inl) ⊔ MonoidHom.mrange (f.comp inr) 
goal: AddMonoidHom.mrange f =
  AddMonoidHom.mrange (f.comp AddMonoid.Coprod.inl) ⊔ AddMonoidHom.mrange (f.comp AddMonoid.Coprod.inr)

full_name: AddMonoid.Coprod.hom_ext
code: /-- 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. -/
@[to_additive (attr := ext 1100)
  "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 hom_ext {f g : M ∗ N →* P} (h₁ : f.comp inl = g.comp inl) (h₂ : f.comp inr = g.comp inr) :
    f = g 
goal: f = g

full_name: Monoid.Coprod.hom_ext
code: /-- 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. -/
@[to_additive (attr := ext 1100)
  "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 hom_ext {f g : M ∗ N →* P} (h₁ : f.comp inl = g.comp inl) (h₂ : f.comp inr = g.comp inr) :
    f = g 
goal: f = g

full_name: Monoid.Coprod.clift_mk
code: @[to_additive (attr := simp)]
theorem clift_mk :
    clift (mk : FreeMonoid (M ⊕ N) →* M ∗ N) (map_one inl) (map_one inr) (map_mul inl)
      (map_mul inr) = .id _ 
goal: Monoid.Coprod.clift Monoid.Coprod.mk ⋯ ⋯ ⋯ ⋯ = MonoidHom.id (Monoid.Coprod M N)

full_name: AddMonoid.Coprod.clift_mk
code: @[to_additive (attr := simp)]
theorem clift_mk :
    clift (mk : FreeMonoid (M ⊕ N) →* M ∗ N) (map_one inl) (map_one inr) (map_mul inl)
      (map_mul inr) = .id _ 
goal: AddMonoid.Coprod.clift AddMonoid.Coprod.mk ⋯ ⋯ ⋯ ⋯ = AddMonoidHom.id (AddMonoid.Coprod M N)

full_name: AddMonoid.Coprod.map
code: /-- Map `M ∗ N` to `M' ∗ N'` by applying `Sum.map f g` to each element of the underlying list. -/
@[to_additive "Map `AddMonoid.Coprod M N` to `AddMonoid.Coprod M' N'`
by applying `Sum.map f g` to each element of the underlying list."]
def map (f : M →* M') (g : N →* N') : M ∗ N →* M' ∗ N' 
goal: AddMonoid.Coprod M N →+ AddMonoid.Coprod M' N'

full_name: Monoid.Coprod.map
code: /-- Map `M ∗ N` to `M' ∗ N'` by applying `Sum.map f g` to each element of the underlying list. -/
@[to_additive "Map `AddMonoid.Coprod M N` to `AddMonoid.Coprod M' N'`
by applying `Sum.map f g` to each element of the underlying list."]
def map (f : M →* M') (g : N →* N') : M ∗ N →* M' ∗ N' 
goal: Monoid.Coprod M N →* Monoid.Coprod M' N'

full_name: Monoid.Coprod.map_mk_ofList
code: @[to_additive (attr := simp)]
theorem map_mk_ofList (f : M →* M') (g : N →* N') (l : List (M ⊕ N)) :
    map f g (mk (ofList l)) = mk (ofList (l.map (Sum.map f g))) 
goal: (Monoid.Coprod.map f g) (Monoid.Coprod.mk (FreeMonoid.ofList l)) =
  Monoid.Coprod.mk (FreeMonoid.ofList (List.map (Sum.map ⇑f ⇑g) l))

full_name: AddMonoid.Coprod.map_mk_ofList
code: @[to_additive (attr := simp)]
theorem map_mk_ofList (f : M →* M') (g : N →* N') (l : List (M ⊕ N)) :
    map f g (mk (ofList l)) = mk (ofList (l.map (Sum.map f g))) 
goal: (AddMonoid.Coprod.map f g) (AddMonoid.Coprod.mk (FreeAddMonoid.ofList l)) =
  AddMonoid.Coprod.mk (FreeAddMonoid.ofList (List.map (Sum.map ⇑f ⇑g) l))

full_name: AddMonoid.Coprod.map_apply_inl
code: @[to_additive (attr := simp)]
theorem map_apply_inl (f : M →* M') (g : N →* N') (x : M) : map f g (inl x) = inl (f x) 
goal: (AddMonoid.Coprod.map f g) (AddMonoid.Coprod.inl x) = AddMonoid.Coprod.inl (f x)

full_name: Monoid.Coprod.map_apply_inl
code: @[to_additive (attr := simp)]
theorem map_apply_inl (f : M →* M') (g : N →* N') (x : M) : map f g (inl x) = inl (f x) 
goal: (Monoid.Coprod.map f g) (Monoid.Coprod.inl x) = Monoid.Coprod.inl (f x)

full_name: Monoid.Coprod.map_apply_inr
code: @[to_additive (attr := simp)]
theorem map_apply_inr (f : M →* M') (g : N →* N') (x : N) : map f g (inr x) = inr (g x) 
goal: (Monoid.Coprod.map f g) (Monoid.Coprod.inr x) = Monoid.Coprod.inr (g x)

full_name: AddMonoid.Coprod.map_apply_inr
code: @[to_additive (attr := simp)]
theorem map_apply_inr (f : M →* M') (g : N →* N') (x : N) : map f g (inr x) = inr (g x) 
goal: (AddMonoid.Coprod.map f g) (AddMonoid.Coprod.inr x) = AddMonoid.Coprod.inr (g x)

full_name: Monoid.Coprod.map_comp_inl
code: @[to_additive (attr := simp)]
theorem map_comp_inl (f : M →* M') (g : N →* N') : (map f g).comp inl = inl.comp f 
goal: (Monoid.Coprod.map f g).comp Monoid.Coprod.inl = Monoid.Coprod.inl.comp f

full_name: AddMonoid.Coprod.map_comp_inl
code: @[to_additive (attr := simp)]
theorem map_comp_inl (f : M →* M') (g : N →* N') : (map f g).comp inl = inl.comp f 
goal: (AddMonoid.Coprod.map f g).comp AddMonoid.Coprod.inl = AddMonoid.Coprod.inl.comp f

full_name: AddMonoid.Coprod.map_comp_inr
code: @[to_additive (attr := simp)]
theorem map_comp_inr (f : M →* M') (g : N →* N') : (map f g).comp inr = inr.comp g 
goal: (AddMonoid.Coprod.map f g).comp AddMonoid.Coprod.inr = AddMonoid.Coprod.inr.comp g

full_name: Monoid.Coprod.map_comp_inr
code: @[to_additive (attr := simp)]
theorem map_comp_inr (f : M →* M') (g : N →* N') : (map f g).comp inr = inr.comp g 
goal: (Monoid.Coprod.map f g).comp Monoid.Coprod.inr = Monoid.Coprod.inr.comp g

full_name: AddMonoid.Coprod.map_id_id
code: @[to_additive (attr := simp)]
theorem map_id_id : map (.id M) (.id N) = .id (M ∗ N) 
goal: AddMonoid.Coprod.map (AddMonoidHom.id M) (AddMonoidHom.id N) = AddMonoidHom.id (AddMonoid.Coprod M N)

full_name: Monoid.Coprod.map_id_id
code: @[to_additive (attr := simp)]
theorem map_id_id : map (.id M) (.id N) = .id (M ∗ N) 
goal: Monoid.Coprod.map (MonoidHom.id M) (MonoidHom.id N) = MonoidHom.id (Monoid.Coprod M N)

full_name: Monoid.Coprod.map_comp_map
code: @[to_additive]
theorem map_comp_map {M'' N''} [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) 
goal: (Monoid.Coprod.map f' g').comp (Monoid.Coprod.map f g) = Monoid.Coprod.map (f'.comp f) (g'.comp g)

full_name: AddMonoid.Coprod.map_comp_map
code: @[to_additive]
theorem map_comp_map {M'' N''} [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) 
goal: (AddMonoid.Coprod.map f' g').comp (AddMonoid.Coprod.map f g) = AddMonoid.Coprod.map (f'.comp f) (g'.comp g)

full_name: Monoid.Coprod.map_map
code: @[to_additive]
theorem map_map {M'' N''} [MulOneClass M''] [MulOneClass N''] (f' : M' →* M'') (g' : N' →* N'')
    (f : M →* M') (g : N →* N') (x : M ∗ N) :
    map f' g' (map f g x) = map (f'.comp f) (g'.comp g) x 
goal: (Monoid.Coprod.map f' g') ((Monoid.Coprod.map f g) x) = (Monoid.Coprod.map (f'.comp f) (g'.comp g)) x

full_name: AddMonoid.Coprod.map_map
code: @[to_additive]
theorem map_map {M'' N''} [MulOneClass M''] [MulOneClass N''] (f' : M' →* M'') (g' : N' →* N'')
    (f : M →* M') (g : N →* N') (x : M ∗ N) :
    map f' g' (map f g x) = map (f'.comp f) (g'.comp g) x 
goal: (AddMonoid.Coprod.map f' g') ((AddMonoid.Coprod.map f g) x) = (AddMonoid.Coprod.map (f'.comp f) (g'.comp g)) x

full_name: AddMonoid.Coprod.swap
code: /-- 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. -/
@[to_additive "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."]
def swap : M ∗ N →* N ∗ M 
goal: AddMonoid.Coprod M N →+ AddMonoid.Coprod N M

full_name: Monoid.Coprod.swap
code: /-- 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. -/
@[to_additive "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."]
def swap : M ∗ N →* N ∗ M 
goal: Monoid.Coprod M N →* Monoid.Coprod N M

full_name: AddMonoid.Coprod.swap_comp_swap
code: @[to_additive (attr := simp)]
theorem swap_comp_swap : (swap M N).comp (swap N M) = .id _ 
goal: (AddMonoid.Coprod.swap M N).comp (AddMonoid.Coprod.swap N M) = AddMonoidHom.id (AddMonoid.Coprod N M)

full_name: Monoid.Coprod.swap_comp_swap
code: @[to_additive (attr := simp)]
theorem swap_comp_swap : (swap M N).comp (swap N M) = .id _ 
goal: (Monoid.Coprod.swap M N).comp (Monoid.Coprod.swap N M) = MonoidHom.id (Monoid.Coprod N M)

full_name: Monoid.Coprod.swap_swap
code: @[to_additive (attr := simp)]
theorem swap_swap (x : M ∗ N) : swap N M (swap M N x) = x 
goal: (Monoid.Coprod.swap N M) ((Monoid.Coprod.swap M N) x) = x

full_name: AddMonoid.Coprod.swap_swap
code: @[to_additive (attr := simp)]
theorem swap_swap (x : M ∗ N) : swap N M (swap M N x) = x 
goal: (AddMonoid.Coprod.swap N M) ((AddMonoid.Coprod.swap M N) x) = x

full_name: AddMonoid.Coprod.swap_comp_map
code: @[to_additive]
theorem swap_comp_map (f : M →* M') (g : N →* N') :
    (swap M' N').comp (map f g) = (map g f).comp (swap M N) 
goal: (AddMonoid.Coprod.swap M' N').comp (AddMonoid.Coprod.map f g) =
  (AddMonoid.Coprod.map g f).comp (AddMonoid.Coprod.swap M N)

full_name: Monoid.Coprod.swap_comp_map
code: @[to_additive]
theorem swap_comp_map (f : M →* M') (g : N →* N') :
    (swap M' N').comp (map f g) = (map g f).comp (swap M N) 
goal: (Monoid.Coprod.swap M' N').comp (Monoid.Coprod.map f g) = (Monoid.Coprod.map g f).comp (Monoid.Coprod.swap M N)

full_name: AddMonoid.Coprod.swap_map
code: @[to_additive]
theorem swap_map (f : M →* M') (g : N →* N') (x : M ∗ N) :
    swap M' N' (map f g x) = map g f (swap M N x) 
goal: (AddMonoid.Coprod.swap M' N') ((AddMonoid.Coprod.map f g) x) =
  (AddMonoid.Coprod.map g f) ((AddMonoid.Coprod.swap M N) x)

full_name: Monoid.Coprod.swap_map
code: @[to_additive]
theorem swap_map (f : M →* M') (g : N →* N') (x : M ∗ N) :
    swap M' N' (map f g x) = map g f (swap M N x) 
goal: (Monoid.Coprod.swap M' N') ((Monoid.Coprod.map f g) x) = (Monoid.Coprod.map g f) ((Monoid.Coprod.swap M N) x)

full_name: Monoid.Coprod.swap_comp_inl
code: @[to_additive (attr := simp)] theorem swap_comp_inl : (swap M N).comp inl = inr 
goal: (Monoid.Coprod.swap M N).comp Monoid.Coprod.inl = Monoid.Coprod.inr

full_name: AddMonoid.Coprod.swap_comp_inl
code: @[to_additive (attr := simp)] theorem swap_comp_inl : (swap M N).comp inl = inr 
goal: (AddMonoid.Coprod.swap M N).comp AddMonoid.Coprod.inl = AddMonoid.Coprod.inr

full_name: Monoid.Coprod.swap_inl
code: @[to_additive (attr := simp)] theorem swap_inl (x : M) : swap M N (inl x) = inr x 
goal: (Monoid.Coprod.swap M N) (Monoid.Coprod.inl x) = Monoid.Coprod.inr x

full_name: AddMonoid.Coprod.swap_inl
code: @[to_additive (attr := simp)] theorem swap_inl (x : M) : swap M N (inl x) = inr x 
goal: (AddMonoid.Coprod.swap M N) (AddMonoid.Coprod.inl x) = AddMonoid.Coprod.inr x

full_name: AddMonoid.Coprod.swap_comp_inr
code: @[to_additive (attr := simp)] theorem swap_comp_inr : (swap M N).comp inr = inl 
goal: (AddMonoid.Coprod.swap M N).comp AddMonoid.Coprod.inr = AddMonoid.Coprod.inl

full_name: Monoid.Coprod.swap_comp_inr
code: @[to_additive (attr := simp)] theorem swap_comp_inr : (swap M N).comp inr = inl 
goal: (Monoid.Coprod.swap M N).comp Monoid.Coprod.inr = Monoid.Coprod.inl

full_name: Monoid.Coprod.swap_inr
code: @[to_additive (attr := simp)] theorem swap_inr (x : N) : swap M N (inr x) = inl x 
goal: (Monoid.Coprod.swap M N) (Monoid.Coprod.inr x) = Monoid.Coprod.inl x

full_name: AddMonoid.Coprod.swap_inr
code: @[to_additive (attr := simp)] theorem swap_inr (x : N) : swap M N (inr x) = inl x 
goal: (AddMonoid.Coprod.swap M N) (AddMonoid.Coprod.inr x) = AddMonoid.Coprod.inl x

full_name: Monoid.Coprod.swap_injective
code: @[to_additive]
theorem swap_injective : Injective (swap M N) 
goal: Function.Injective ⇑(Monoid.Coprod.swap M N)

full_name: AddMonoid.Coprod.swap_injective
code: @[to_additive]
theorem swap_injective : Injective (swap M N) 
goal: Function.Injective ⇑(AddMonoid.Coprod.swap M N)

full_name: Monoid.Coprod.swap_inj
code: @[to_additive (attr := simp)]
theorem swap_inj {x y : M ∗ N} : swap M N x = swap M N y ↔ x = y 
goal: (Monoid.Coprod.swap M N) x = (Monoid.Coprod.swap M N) y ↔ x = y

full_name: AddMonoid.Coprod.swap_inj
code: @[to_additive (attr := simp)]
theorem swap_inj {x y : M ∗ N} : swap M N x = swap M N y ↔ x = y 
goal: (AddMonoid.Coprod.swap M N) x = (AddMonoid.Coprod.swap M N) y ↔ x = y

full_name: AddMonoid.Coprod.swap_eq_zero
code: @[to_additive (attr := simp)]
theorem swap_eq_one {x : M ∗ N} : swap M N x = 1 ↔ x = 1 
goal: (AddMonoid.Coprod.swap M N) x = 0 ↔ x = 0

full_name: Monoid.Coprod.swap_eq_one
code: @[to_additive (attr := simp)]
theorem swap_eq_one {x : M ∗ N} : swap M N x = 1 ↔ x = 1 
goal: (Monoid.Coprod.swap M N) x = 1 ↔ x = 1

full_name: AddMonoid.Coprod.swap_surjective
code: @[to_additive]
theorem swap_surjective : Surjective (swap M N) 
goal: Function.Surjective ⇑(AddMonoid.Coprod.swap M N)

full_name: Monoid.Coprod.swap_surjective
code: @[to_additive]
theorem swap_surjective : Surjective (swap M N) 
goal: Function.Surjective ⇑(Monoid.Coprod.swap M N)

full_name: AddMonoid.Coprod.swap_bijective
code: @[to_additive]
theorem swap_bijective : Bijective (swap M N) 
goal: Function.Bijective ⇑(AddMonoid.Coprod.swap M N)

full_name: Monoid.Coprod.swap_bijective
code: @[to_additive]
theorem swap_bijective : Bijective (swap M N) 
goal: Function.Bijective ⇑(Monoid.Coprod.swap M N)

full_name: Monoid.Coprod.mker_swap
code: @[to_additive (attr := simp)]
theorem mker_swap : MonoidHom.mker (swap M N) = ⊥ 
goal: MonoidHom.mker (Monoid.Coprod.swap M N) = ⊥

full_name: AddMonoid.Coprod.mker_swap
code: @[to_additive (attr := simp)]
theorem mker_swap : MonoidHom.mker (swap M N) = ⊥ 
goal: AddMonoidHom.mker (AddMonoid.Coprod.swap M N) = ⊥

full_name: AddMonoid.Coprod.mrange_swap
code: @[to_additive (attr := simp)]
theorem mrange_swap : MonoidHom.mrange (swap M N) = ⊤ 
goal: AddMonoidHom.mrange (AddMonoid.Coprod.swap M N) = ⊤

full_name: Monoid.Coprod.mrange_swap
code: @[to_additive (attr := simp)]
theorem mrange_swap : MonoidHom.mrange (swap M N) = ⊤ 
goal: MonoidHom.mrange (Monoid.Coprod.swap M N) = ⊤

full_name: AddMonoid.Coprod.lift
code: /-- 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.
-/
@[to_additive "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."]
def lift (f : M →* P) (g : N →* P) : (M ∗ N) →* P 
goal: AddMonoid.Coprod M N →+ P

full_name: Monoid.Coprod.lift
code: /-- 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.
-/
@[to_additive "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."]
def lift (f : M →* P) (g : N →* P) : (M ∗ N) →* P 
goal: Monoid.Coprod M N →* P

full_name: Monoid.Coprod.lift_apply_mk
code: @[to_additive (attr := simp)]
theorem lift_apply_mk (f : M →* P) (g : N →* P) (x : FreeMonoid (M ⊕ N)) :
    lift f g (mk x) = FreeMonoid.lift (Sum.elim f g) x 
goal: (Monoid.Coprod.lift f g) (Monoid.Coprod.mk x) = (FreeMonoid.lift (Sum.elim ⇑f ⇑g)) x

full_name: AddMonoid.Coprod.lift_apply_mk
code: @[to_additive (attr := simp)]
theorem lift_apply_mk (f : M →* P) (g : N →* P) (x : FreeMonoid (M ⊕ N)) :
    lift f g (mk x) = FreeMonoid.lift (Sum.elim f g) x 
goal: (AddMonoid.Coprod.lift f g) (AddMonoid.Coprod.mk x) = (FreeAddMonoid.lift (Sum.elim ⇑f ⇑g)) x

full_name: AddMonoid.Coprod.lift_apply_inl
code: @[to_additive (attr := simp)]
theorem lift_apply_inl (f : M →* P) (g : N →* P) (x : M) : lift f g (inl x) = f x 
goal: (AddMonoid.Coprod.lift f g) (AddMonoid.Coprod.inl x) = f x

full_name: Monoid.Coprod.lift_apply_inl
code: @[to_additive (attr := simp)]
theorem lift_apply_inl (f : M →* P) (g : N →* P) (x : M) : lift f g (inl x) = f x 
goal: (Monoid.Coprod.lift f g) (Monoid.Coprod.inl x) = f x

full_name: AddMonoid.Coprod.lift_unique
code: @[to_additive]
theorem lift_unique {f : M →* P} {g : N →* P} {fg : M ∗ N →* P} (h₁ : fg.comp inl = f)
    (h₂ : fg.comp inr = g) : fg = lift f g 
goal: fg = AddMonoid.Coprod.lift f g

full_name: Monoid.Coprod.lift_unique
code: @[to_additive]
theorem lift_unique {f : M →* P} {g : N →* P} {fg : M ∗ N →* P} (h₁ : fg.comp inl = f)
    (h₂ : fg.comp inr = g) : fg = lift f g 
goal: fg = Monoid.Coprod.lift f g

full_name: Monoid.Coprod.lift_comp_inl
code: @[to_additive (attr := simp)]
theorem lift_comp_inl (f : M →* P) (g : N →* P) : (lift f g).comp inl = f 
goal: (Monoid.Coprod.lift f g).comp Monoid.Coprod.inl = f

full_name: AddMonoid.Coprod.lift_comp_inl
code: @[to_additive (attr := simp)]
theorem lift_comp_inl (f : M →* P) (g : N →* P) : (lift f g).comp inl = f 
goal: (AddMonoid.Coprod.lift f g).comp AddMonoid.Coprod.inl = f

full_name: AddMonoid.Coprod.lift_apply_inr
code: @[to_additive (attr := simp)]
theorem lift_apply_inr (f : M →* P) (g : N →* P) (x : N) : lift f g (inr x) = g x 
goal: (AddMonoid.Coprod.lift f g) (AddMonoid.Coprod.inr x) = g x

full_name: Monoid.Coprod.lift_apply_inr
code: @[to_additive (attr := simp)]
theorem lift_apply_inr (f : M →* P) (g : N →* P) (x : N) : lift f g (inr x) = g x 
goal: (Monoid.Coprod.lift f g) (Monoid.Coprod.inr x) = g x

full_name: Monoid.Coprod.lift_comp_inr
code: @[to_additive (attr := simp)]
theorem lift_comp_inr (f : M →* P) (g : N →* P) : (lift f g).comp inr = g 
goal: (Monoid.Coprod.lift f g).comp Monoid.Coprod.inr = g

full_name: AddMonoid.Coprod.lift_comp_inr
code: @[to_additive (attr := simp)]
theorem lift_comp_inr (f : M →* P) (g : N →* P) : (lift f g).comp inr = g 
goal: (AddMonoid.Coprod.lift f g).comp AddMonoid.Coprod.inr = g

full_name: AddMonoid.Coprod.lift_comp_swap
code: @[to_additive (attr := simp)]
theorem lift_comp_swap (f : M →* P) (g : N →* P) : (lift f g).comp (swap N M) = lift g f 
goal: (AddMonoid.Coprod.lift f g).comp (AddMonoid.Coprod.swap N M) = AddMonoid.Coprod.lift g f

full_name: Monoid.Coprod.lift_comp_swap
code: @[to_additive (attr := simp)]
theorem lift_comp_swap (f : M →* P) (g : N →* P) : (lift f g).comp (swap N M) = lift g f 
goal: (Monoid.Coprod.lift f g).comp (Monoid.Coprod.swap N M) = Monoid.Coprod.lift g f

full_name: AddMonoid.Coprod.lift_swap
code: @[to_additive (attr := simp)]
theorem lift_swap (f : M →* P) (g : N →* P) (x : N ∗ M) : lift f g (swap N M x) = lift g f x 
goal: (AddMonoid.Coprod.lift f g) ((AddMonoid.Coprod.swap N M) x) = (AddMonoid.Coprod.lift g f) x

full_name: Monoid.Coprod.lift_swap
code: @[to_additive (attr := simp)]
theorem lift_swap (f : M →* P) (g : N →* P) (x : N ∗ M) : lift f g (swap N M x) = lift g f x 
goal: (Monoid.Coprod.lift f g) ((Monoid.Coprod.swap N M) x) = (Monoid.Coprod.lift g f) x

full_name: AddMonoid.Coprod.comp_lift
code: @[to_additive]
theorem comp_lift {P' : Type*} [Monoid P'] (f : P →* P') (g₁ : M →* P) (g₂ : N →* P) :
    f.comp (lift g₁ g₂) = lift (f.comp g₁) (f.comp g₂) 
goal: f.comp (AddMonoid.Coprod.lift g₁ g₂) = AddMonoid.Coprod.lift (f.comp g₁) (f.comp g₂)

full_name: Monoid.Coprod.comp_lift
code: @[to_additive]
theorem comp_lift {P' : Type*} [Monoid P'] (f : P →* P') (g₁ : M →* P) (g₂ : N →* P) :
    f.comp (lift g₁ g₂) = lift (f.comp g₁) (f.comp g₂) 
goal: f.comp (Monoid.Coprod.lift g₁ g₂) = Monoid.Coprod.lift (f.comp g₁) (f.comp g₂)

full_name: Monoid.Coprod.liftEquiv
code: /-- `Coprod.lift` as an equivalence. -/
@[to_additive "`AddMonoid.Coprod.lift` as an equivalence."]
def liftEquiv : (M →* P) × (N →* P) ≃ (M ∗ N →* P) 
goal: (M →* P) × (N →* P) ≃ (Monoid.Coprod M N →* P)

full_name: AddMonoid.Coprod.liftEquiv
code: /-- `Coprod.lift` as an equivalence. -/
@[to_additive "`AddMonoid.Coprod.lift` as an equivalence."]
def liftEquiv : (M →* P) × (N →* P) ≃ (M ∗ N →* P) 
goal: (M →+ P) × (N →+ P) ≃ (AddMonoid.Coprod M N →+ P)

full_name: AddMonoid.Coprod.mrange_lift
code: @[to_additive (attr := simp)]
theorem mrange_lift (f : M →* P) (g : N →* P) :
    MonoidHom.mrange (lift f g) = MonoidHom.mrange f ⊔ MonoidHom.mrange g 
goal: AddMonoidHom.mrange (AddMonoid.Coprod.lift f g) = AddMonoidHom.mrange f ⊔ AddMonoidHom.mrange g

full_name: Monoid.Coprod.mrange_lift
code: @[to_additive (attr := simp)]
theorem mrange_lift (f : M →* P) (g : N →* P) :
    MonoidHom.mrange (lift f g) = MonoidHom.mrange f ⊔ MonoidHom.mrange g 
goal: MonoidHom.mrange (Monoid.Coprod.lift f g) = MonoidHom.mrange f ⊔ MonoidHom.mrange g

full_name: AddMonoid.Coprod.inst
code: @[to_additive] instance : Monoid (M ∗ N) 
goal: AddMonoid (AddMonoid.Coprod M N)

full_name: Monoid.Coprod.inst
code: @[to_additive] instance : Monoid (M ∗ N) 
goal: Monoid (Monoid.Coprod M N)

full_name: AddMonoid.Coprod.fst
code: /-- The natural projection `M ∗ N →* M`. -/
@[to_additive "The natural projection `AddMonoid.Coprod M N →+ M`."]
def fst : M ∗ N →* M 
goal: AddMonoid.Coprod M N →+ M

full_name: Monoid.Coprod.fst
code: /-- The natural projection `M ∗ N →* M`. -/
@[to_additive "The natural projection `AddMonoid.Coprod M N →+ M`."]
def fst : M ∗ N →* M 
goal: Monoid.Coprod M N →* M

full_name: Monoid.Coprod.snd
code: /-- The natural projection `M ∗ N →* N`. -/
@[to_additive "The natural projection `AddMonoid.Coprod M N →+ N`."]
def snd : M ∗ N →* N 
goal: Monoid.Coprod M N →* N

full_name: AddMonoid.Coprod.snd
code: /-- The natural projection `M ∗ N →* N`. -/
@[to_additive "The natural projection `AddMonoid.Coprod M N →+ N`."]
def snd : M ∗ N →* N 
goal: AddMonoid.Coprod M N →+ N

full_name: AddMonoid.Coprod.toSum
code: /-- The natural projection `M ∗ N →* M × N`. -/
@[to_additive "The natural projection `AddMonoid.Coprod M N →+ M × N`."]
def toProd : M ∗ N →* M × N 
goal: AddMonoid.Coprod M N →+ M × N

full_name: Monoid.Coprod.toProd
code: /-- The natural projection `M ∗ N →* M × N`. -/
@[to_additive "The natural projection `AddMonoid.Coprod M N →+ M × N`."]
def toProd : M ∗ N →* M × N 
goal: Monoid.Coprod M N →* M × N

full_name: AddMonoid.Coprod.fst_comp_inl
code: @[to_additive (attr := simp)] theorem fst_comp_inl : (fst : M ∗ N →* M).comp inl = .id _ 
goal: AddMonoid.Coprod.fst.comp AddMonoid.Coprod.inl = AddMonoidHom.id M

full_name: Monoid.Coprod.fst_comp_inl
code: @[to_additive (attr := simp)] theorem fst_comp_inl : (fst : M ∗ N →* M).comp inl = .id _ 
goal: Monoid.Coprod.fst.comp Monoid.Coprod.inl = MonoidHom.id M

full_name: AddMonoid.Coprod.fst_apply_inl
code: @[to_additive (attr := simp)] theorem fst_apply_inl (x : M) : fst (inl x : M ∗ N) = x 
goal: AddMonoid.Coprod.fst (AddMonoid.Coprod.inl x) = x

full_name: Monoid.Coprod.fst_apply_inl
code: @[to_additive (attr := simp)] theorem fst_apply_inl (x : M) : fst (inl x : M ∗ N) = x 
goal: Monoid.Coprod.fst (Monoid.Coprod.inl x) = x

full_name: AddMonoid.Coprod.fst_comp_inr
code: @[to_additive (attr := simp)] theorem fst_comp_inr : (fst : M ∗ N →* M).comp inr = 1 
goal: AddMonoid.Coprod.fst.comp AddMonoid.Coprod.inr = 0

full_name: Monoid.Coprod.fst_comp_inr
code: @[to_additive (attr := simp)] theorem fst_comp_inr : (fst : M ∗ N →* M).comp inr = 1 
goal: Monoid.Coprod.fst.comp Monoid.Coprod.inr = 1

full_name: AddMonoid.Coprod.fst_apply_inr
code: @[to_additive (attr := simp)] theorem fst_apply_inr (x : N) : fst (inr x : M ∗ N) = 1 
goal: AddMonoid.Coprod.fst (AddMonoid.Coprod.inr x) = 0

full_name: Monoid.Coprod.fst_apply_inr
code: @[to_additive (attr := simp)] theorem fst_apply_inr (x : N) : fst (inr x : M ∗ N) = 1 
goal: Monoid.Coprod.fst (Monoid.Coprod.inr x) = 1

full_name: Monoid.Coprod.snd_comp_inl
code: @[to_additive (attr := simp)] theorem snd_comp_inl : (snd : M ∗ N →* N).comp inl = 1 
goal: Monoid.Coprod.snd.comp Monoid.Coprod.inl = 1

full_name: AddMonoid.Coprod.snd_comp_inl
code: @[to_additive (attr := simp)] theorem snd_comp_inl : (snd : M ∗ N →* N).comp inl = 1 
goal: AddMonoid.Coprod.snd.comp AddMonoid.Coprod.inl = 0

full_name: Monoid.Coprod.snd_apply_inl
code: @[to_additive (attr := simp)] theorem snd_apply_inl (x : M) : snd (inl x : M ∗ N) = 1 
goal: Monoid.Coprod.snd (Monoid.Coprod.inl x) = 1

full_name: AddMonoid.Coprod.snd_apply_inl
code: @[to_additive (attr := simp)] theorem snd_apply_inl (x : M) : snd (inl x : M ∗ N) = 1 
goal: AddMonoid.Coprod.snd (AddMonoid.Coprod.inl x) = 0

full_name: Monoid.Coprod.snd_comp_inr
code: @[to_additive (attr := simp)] theorem snd_comp_inr : (snd : M ∗ N →* N).comp inr = .id _ 
goal: Monoid.Coprod.snd.comp Monoid.Coprod.inr = MonoidHom.id N

full_name: AddMonoid.Coprod.snd_comp_inr
code: @[to_additive (attr := simp)] theorem snd_comp_inr : (snd : M ∗ N →* N).comp inr = .id _ 
goal: AddMonoid.Coprod.snd.comp AddMonoid.Coprod.inr = AddMonoidHom.id N

full_name: AddMonoid.Coprod.snd_apply_inr
code: @[to_additive (attr := simp)] theorem snd_apply_inr (x : N) : snd (inr x : M ∗ N) = x 
goal: AddMonoid.Coprod.snd (AddMonoid.Coprod.inr x) = x

full_name: Monoid.Coprod.snd_apply_inr
code: @[to_additive (attr := simp)] theorem snd_apply_inr (x : N) : snd (inr x : M ∗ N) = x 
goal: Monoid.Coprod.snd (Monoid.Coprod.inr x) = x

full_name: Monoid.Coprod.toProd_comp_inl
code: @[to_additive (attr := simp)]
theorem toProd_comp_inl : (toProd : M ∗ N →* M × N).comp inl = .inl _ _ 
goal: Monoid.Coprod.toProd.comp Monoid.Coprod.inl = MonoidHom.inl M N

full_name: AddMonoid.Coprod.toSum_comp_inl
code: @[to_additive (attr := simp)]
theorem toProd_comp_inl : (toProd : M ∗ N →* M × N).comp inl = .inl _ _ 
goal: AddMonoid.Coprod.toSum.comp AddMonoid.Coprod.inl = AddMonoidHom.inl M N

full_name: AddMonoid.Coprod.toSum_comp_inr
code: @[to_additive (attr := simp)]
theorem toProd_comp_inr : (toProd : M ∗ N →* M × N).comp inr = .inr _ _ 
goal: AddMonoid.Coprod.toSum.comp AddMonoid.Coprod.inr = AddMonoidHom.inr M N

full_name: Monoid.Coprod.toProd_comp_inr
code: @[to_additive (attr := simp)]
theorem toProd_comp_inr : (toProd : M ∗ N →* M × N).comp inr = .inr _ _ 
goal: Monoid.Coprod.toProd.comp Monoid.Coprod.inr = MonoidHom.inr M N

full_name: Monoid.Coprod.toProd_apply_inl
code: @[to_additive (attr := simp)]
theorem toProd_apply_inl (x : M) : toProd (inl x : M ∗ N) = (x, 1) 
goal: Monoid.Coprod.toProd (Monoid.Coprod.inl x) = (x, 1)

full_name: AddMonoid.Coprod.toSum_apply_inl
code: @[to_additive (attr := simp)]
theorem toProd_apply_inl (x : M) : toProd (inl x : M ∗ N) = (x, 1) 
goal: AddMonoid.Coprod.toSum (AddMonoid.Coprod.inl x) = (x, 0)

full_name: AddMonoid.Coprod.toSum_apply_inr
code: @[to_additive (attr := simp)]
theorem toProd_apply_inr (x : N) : toProd (inr x : M ∗ N) = (1, x) 
goal: AddMonoid.Coprod.toSum (AddMonoid.Coprod.inr x) = (0, x)

full_name: Monoid.Coprod.toProd_apply_inr
code: @[to_additive (attr := simp)]
theorem toProd_apply_inr (x : N) : toProd (inr x : M ∗ N) = (1, x) 
goal: Monoid.Coprod.toProd (Monoid.Coprod.inr x) = (1, x)

full_name: Monoid.Coprod.fst_prod_snd
code: @[to_additive (attr := simp)]
theorem fst_prod_snd : (fst : M ∗ N →* M).prod snd = toProd 
goal: Monoid.Coprod.fst.prod Monoid.Coprod.snd = Monoid.Coprod.toProd

full_name: AddMonoid.Coprod.fst_sum_snd
code: @[to_additive (attr := simp)]
theorem fst_prod_snd : (fst : M ∗ N →* M).prod snd = toProd 
goal: AddMonoid.Coprod.fst.prod AddMonoid.Coprod.snd = AddMonoid.Coprod.toSum

full_name: AddMonoid.Coprod.sum_mk_fst_snd
code: @[to_additive (attr := simp)]
theorem prod_mk_fst_snd (x : M ∗ N) : (fst x, snd x) = toProd x 
goal: (AddMonoid.Coprod.fst x, AddMonoid.Coprod.snd x) = AddMonoid.Coprod.toSum x

full_name: Monoid.Coprod.prod_mk_fst_snd
code: @[to_additive (attr := simp)]
theorem prod_mk_fst_snd (x : M ∗ N) : (fst x, snd x) = toProd x 
goal: (Monoid.Coprod.fst x, Monoid.Coprod.snd x) = Monoid.Coprod.toProd x

full_name: Monoid.Coprod.fst_comp_toProd
code: @[to_additive (attr := simp)]
theorem fst_comp_toProd : (MonoidHom.fst M N).comp toProd = fst 
goal: (MonoidHom.fst M N).comp Monoid.Coprod.toProd = Monoid.Coprod.fst

full_name: AddMonoid.Coprod.fst_comp_toSum
code: @[to_additive (attr := simp)]
theorem fst_comp_toProd : (MonoidHom.fst M N).comp toProd = fst 
goal: (AddMonoidHom.fst M N).comp AddMonoid.Coprod.toSum = AddMonoid.Coprod.fst

full_name: Monoid.Coprod.fst_toProd
code: @[to_additive (attr := simp)]
theorem fst_toProd (x : M ∗ N) : (toProd x).1 = fst x 
goal: (Monoid.Coprod.toProd x).1 = Monoid.Coprod.fst x

full_name: AddMonoid.Coprod.fst_toSum
code: @[to_additive (attr := simp)]
theorem fst_toProd (x : M ∗ N) : (toProd x).1 = fst x 
goal: (AddMonoid.Coprod.toSum x).1 = AddMonoid.Coprod.fst x

full_name: AddMonoid.Coprod.snd_comp_toSum
code: @[to_additive (attr := simp)]
theorem snd_comp_toProd : (MonoidHom.snd M N).comp toProd = snd 
goal: (AddMonoidHom.snd M N).comp AddMonoid.Coprod.toSum = AddMonoid.Coprod.snd

full_name: Monoid.Coprod.snd_comp_toProd
code: @[to_additive (attr := simp)]
theorem snd_comp_toProd : (MonoidHom.snd M N).comp toProd = snd 
goal: (MonoidHom.snd M N).comp Monoid.Coprod.toProd = Monoid.Coprod.snd

full_name: AddMonoid.Coprod.snd_toSum
code: @[to_additive (attr := simp)]
theorem snd_toProd (x : M ∗ N) : (toProd x).2 = snd x 
goal: (AddMonoid.Coprod.toSum x).2 = AddMonoid.Coprod.snd x

full_name: Monoid.Coprod.snd_toProd
code: @[to_additive (attr := simp)]
theorem snd_toProd (x : M ∗ N) : (toProd x).2 = snd x 
goal: (Monoid.Coprod.toProd x).2 = Monoid.Coprod.snd x

full_name: Monoid.Coprod.fst_comp_swap
code: @[to_additive (attr := simp)]
theorem fst_comp_swap : fst.comp (swap M N) = snd 
goal: Monoid.Coprod.fst.comp (Monoid.Coprod.swap M N) = Monoid.Coprod.snd

full_name: AddMonoid.Coprod.fst_comp_swap
code: @[to_additive (attr := simp)]
theorem fst_comp_swap : fst.comp (swap M N) = snd 
goal: AddMonoid.Coprod.fst.comp (AddMonoid.Coprod.swap M N) = AddMonoid.Coprod.snd

full_name: Monoid.Coprod.fst_swap
code: @[to_additive (attr := simp)]
theorem fst_swap (x : M ∗ N) : fst (swap M N x) = snd x 
goal: Monoid.Coprod.fst ((Monoid.Coprod.swap M N) x) = Monoid.Coprod.snd x

full_name: AddMonoid.Coprod.fst_swap
code: @[to_additive (attr := simp)]
theorem fst_swap (x : M ∗ N) : fst (swap M N x) = snd x 
goal: AddMonoid.Coprod.fst ((AddMonoid.Coprod.swap M N) x) = AddMonoid.Coprod.snd x

full_name: AddMonoid.Coprod.snd_comp_swap
code: @[to_additive (attr := simp)]
theorem snd_comp_swap : snd.comp (swap M N) = fst 
goal: AddMonoid.Coprod.snd.comp (AddMonoid.Coprod.swap M N) = AddMonoid.Coprod.fst

full_name: Monoid.Coprod.snd_comp_swap
code: @[to_additive (attr := simp)]
theorem snd_comp_swap : snd.comp (swap M N) = fst 
goal: Monoid.Coprod.snd.comp (Monoid.Coprod.swap M N) = Monoid.Coprod.fst

full_name: AddMonoid.Coprod.snd_swap
code: @[to_additive (attr := simp)]
theorem snd_swap (x : M ∗ N) : snd (swap M N x) = fst x 
goal: AddMonoid.Coprod.snd ((AddMonoid.Coprod.swap M N) x) = AddMonoid.Coprod.fst x

full_name: Monoid.Coprod.snd_swap
code: @[to_additive (attr := simp)]
theorem snd_swap (x : M ∗ N) : snd (swap M N x) = fst x 
goal: Monoid.Coprod.snd ((Monoid.Coprod.swap M N) x) = Monoid.Coprod.fst x

full_name: Monoid.Coprod.lift_inr_inl
code: @[to_additive (attr := simp)]
theorem lift_inr_inl : lift (inr : M →* N ∗ M) inl = swap M N 
goal: Monoid.Coprod.lift Monoid.Coprod.inr Monoid.Coprod.inl = Monoid.Coprod.swap M N

full_name: AddMonoid.Coprod.lift_inr_inl
code: @[to_additive (attr := simp)]
theorem lift_inr_inl : lift (inr : M →* N ∗ M) inl = swap M N 
goal: AddMonoid.Coprod.lift AddMonoid.Coprod.inr AddMonoid.Coprod.inl = AddMonoid.Coprod.swap M N

full_name: Monoid.Coprod.lift_inl_inr
code: @[to_additive (attr := simp)]
theorem lift_inl_inr : lift (inl : M →* M ∗ N) inr = .id _ 
goal: Monoid.Coprod.lift Monoid.Coprod.inl Monoid.Coprod.inr = MonoidHom.id (Monoid.Coprod M N)

full_name: AddMonoid.Coprod.lift_inl_inr
code: @[to_additive (attr := simp)]
theorem lift_inl_inr : lift (inl : M →* M ∗ N) inr = .id _ 
goal: AddMonoid.Coprod.lift AddMonoid.Coprod.inl AddMonoid.Coprod.inr = AddMonoidHom.id (AddMonoid.Coprod M N)

full_name: Monoid.Coprod.inl_injective
code: @[to_additive]
theorem inl_injective : Injective (inl : M →* M ∗ N) 
goal: Function.Injective ⇑Monoid.Coprod.inl

full_name: AddMonoid.Coprod.inl_injective
code: @[to_additive]
theorem inl_injective : Injective (inl : M →* M ∗ N) 
goal: Function.Injective ⇑AddMonoid.Coprod.inl

full_name: AddMonoid.Coprod.inr_injective
code: @[to_additive]
theorem inr_injective : Injective (inr : N →* M ∗ N) 
goal: Function.Injective ⇑AddMonoid.Coprod.inr

full_name: Monoid.Coprod.inr_injective
code: @[to_additive]
theorem inr_injective : Injective (inr : N →* M ∗ N) 
goal: Function.Injective ⇑Monoid.Coprod.inr

full_name: AddMonoid.Coprod.fst_surjective
code: @[to_additive]
theorem fst_surjective : Surjective (fst : M ∗ N →* M) 
goal: Function.Surjective ⇑AddMonoid.Coprod.fst

full_name: Monoid.Coprod.fst_surjective
code: @[to_additive]
theorem fst_surjective : Surjective (fst : M ∗ N →* M) 
goal: Function.Surjective ⇑Monoid.Coprod.fst

full_name: AddMonoid.Coprod.snd_surjective
code: @[to_additive]
theorem snd_surjective : Surjective (snd : M ∗ N →* N) 
goal: Function.Surjective ⇑AddMonoid.Coprod.snd

full_name: Monoid.Coprod.snd_surjective
code: @[to_additive]
theorem snd_surjective : Surjective (snd : M ∗ N →* N) 
goal: Function.Surjective ⇑Monoid.Coprod.snd

full_name: Monoid.Coprod.toProd_surjective
code: @[to_additive]
theorem toProd_surjective : Surjective (toProd : M ∗ N →* M × N) 
goal: Function.Surjective ⇑Monoid.Coprod.toProd

full_name: AddMonoid.Coprod.toSum_surjective
code: @[to_additive]
theorem toProd_surjective : Surjective (toProd : M ∗ N →* M × N) 
goal: Function.Surjective ⇑AddMonoid.Coprod.toSum

full_name: Monoid.Coprod.mk_of_inv_mul
code: @[to_additive]
theorem mk_of_inv_mul : ∀ x : G ⊕ H, mk (of (x.map Inv.inv Inv.inv)) * mk (of x) = 1
  
goal: Monoid.Coprod.mk (FreeMonoid.of (Sum.map Inv.inv Inv.inv x)) * Monoid.Coprod.mk (FreeMonoid.of x) = 1

full_name: AddMonoid.Coprod.mk_of_neg_add
code: @[to_additive]
theorem mk_of_inv_mul : ∀ x : G ⊕ H, mk (of (x.map Inv.inv Inv.inv)) * mk (of x) = 1
  
goal: AddMonoid.Coprod.mk (FreeAddMonoid.of (Sum.map Neg.neg Neg.neg x)) + AddMonoid.Coprod.mk (FreeAddMonoid.of x) = 0

full_name: Monoid.Coprod.con_mul_left_inv
code: @[to_additive]
theorem con_mul_left_inv (x : FreeMonoid (G ⊕ H)) :
    coprodCon G H (ofList (x.toList.map (Sum.map Inv.inv Inv.inv)).reverse * x) 1 
goal: (Monoid.coprodCon G H) (FreeMonoid.ofList (List.map (Sum.map Inv.inv Inv.inv) (FreeMonoid.toList x)).reverse * x) 1

full_name: AddMonoid.Coprod.con_add_left_neg
code: @[to_additive]
theorem con_mul_left_inv (x : FreeMonoid (G ⊕ H)) :
    coprodCon G H (ofList (x.toList.map (Sum.map Inv.inv Inv.inv)).reverse * x) 1 
goal: (AddMonoid.coprodCon G H)
  (FreeAddMonoid.ofList (List.map (Sum.map Neg.neg Neg.neg) (FreeAddMonoid.toList x)).reverse + x) 0

full_name: Monoid.Coprod.instInv
code: @[to_additive]
instance : Inv (G ∗ H) 
goal: Inv (Monoid.Coprod G H)

full_name: AddMonoid.Coprod.instNeg
code: @[to_additive]
instance : Inv (G ∗ H) 
goal: Neg (AddMonoid.Coprod G H)

full_name: Monoid.Coprod.inv_def
code: @[to_additive]
theorem inv_def (w : FreeMonoid (G ⊕ H)) :
    (mk w)⁻¹ = mk (ofList (w.toList.map (Sum.map Inv.inv Inv.inv)).reverse) 
goal: (Monoid.Coprod.mk w)⁻¹ =
  Monoid.Coprod.mk (FreeMonoid.ofList (List.map (Sum.map Inv.inv Inv.inv) (FreeMonoid.toList w)).reverse)

full_name: AddMonoid.Coprod.neg_def
code: @[to_additive]
theorem inv_def (w : FreeMonoid (G ⊕ H)) :
    (mk w)⁻¹ = mk (ofList (w.toList.map (Sum.map Inv.inv Inv.inv)).reverse) 
goal: -AddMonoid.Coprod.mk w =
  AddMonoid.Coprod.mk (FreeAddMonoid.ofList (List.map (Sum.map Neg.neg Neg.neg) (FreeAddMonoid.toList w)).reverse)

full_name: AddMonoid.Coprod.instAddGroup
code: @[to_additive]
instance : Group (G ∗ H) 
goal: AddGroup (AddMonoid.Coprod G H)

full_name: Monoid.Coprod.instGroup
code: @[to_additive]
instance : Group (G ∗ H) 
goal: Group (Monoid.Coprod G H)

full_name: Monoid.Coprod.closure_range_inl_union_inr
code: @[to_additive (attr := simp)]
theorem closure_range_inl_union_inr :
    Subgroup.closure (range (inl : G →* G ∗ H) ∪ range inr) = ⊤ 
goal: Subgroup.closure (Set.range ⇑Monoid.Coprod.inl ∪ Set.range ⇑Monoid.Coprod.inr) = ⊤

full_name: AddMonoid.Coprod.closure_range_inl_union_inr
code: @[to_additive (attr := simp)]
theorem closure_range_inl_union_inr :
    Subgroup.closure (range (inl : G →* G ∗ H) ∪ range inr) = ⊤ 
goal: AddSubgroup.closure (Set.range ⇑AddMonoid.Coprod.inl ∪ Set.range ⇑AddMonoid.Coprod.inr) = ⊤

full_name: Monoid.Coprod.range_inl_sup_range_inr
code: @[to_additive (attr := simp)] theorem range_inl_sup_range_inr :
    MonoidHom.range (inl : G →* G ∗ H) ⊔ MonoidHom.range inr = ⊤ 
goal: Monoid.Coprod.inl.range ⊔ Monoid.Coprod.inr.range = ⊤

full_name: AddMonoid.Coprod.range_inl_sup_range_inr
code: @[to_additive (attr := simp)] theorem range_inl_sup_range_inr :
    MonoidHom.range (inl : G →* G ∗ H) ⊔ MonoidHom.range inr = ⊤ 
goal: AddMonoid.Coprod.inl.range ⊔ AddMonoid.Coprod.inr.range = ⊤

full_name: AddMonoid.Coprod.codisjoint_range_inl_range_inr
code: @[to_additive]
theorem codisjoint_range_inl_range_inr :
    Codisjoint (MonoidHom.range (inl : G →* G ∗ H)) (MonoidHom.range inr) 
goal: Codisjoint AddMonoid.Coprod.inl.range AddMonoid.Coprod.inr.range

full_name: Monoid.Coprod.codisjoint_range_inl_range_inr
code: @[to_additive]
theorem codisjoint_range_inl_range_inr :
    Codisjoint (MonoidHom.range (inl : G →* G ∗ H)) (MonoidHom.range inr) 
goal: Codisjoint Monoid.Coprod.inl.range Monoid.Coprod.inr.range

full_name: Monoid.Coprod.range_swap
code: @[to_additive (attr := simp)] theorem range_swap : MonoidHom.range (swap G H) = ⊤ 
goal: (Monoid.Coprod.swap G H).range = ⊤

full_name: AddMonoid.Coprod.range_swap
code: @[to_additive (attr := simp)] theorem range_swap : MonoidHom.range (swap G H) = ⊤ 
goal: (AddMonoid.Coprod.swap G H).range = ⊤

full_name: AddMonoid.Coprod.range_eq
code: @[to_additive] theorem range_eq (f : G ∗ H →* K) :
    MonoidHom.range f = MonoidHom.range (f.comp inl) ⊔ MonoidHom.range (f.comp inr) 
goal: f.range = (f.comp AddMonoid.Coprod.inl).range ⊔ (f.comp AddMonoid.Coprod.inr).range

full_name: Monoid.Coprod.range_eq
code: @[to_additive] theorem range_eq (f : G ∗ H →* K) :
    MonoidHom.range f = MonoidHom.range (f.comp inl) ⊔ MonoidHom.range (f.comp inr) 
goal: f.range = (f.comp Monoid.Coprod.inl).range ⊔ (f.comp Monoid.Coprod.inr).range

full_name: Monoid.Coprod.range_lift
code: @[to_additive (attr := simp)] theorem range_lift (f : G →* K) (g : H →* K) :
    MonoidHom.range (lift f g) = MonoidHom.range f ⊔ MonoidHom.range g 
goal: (Monoid.Coprod.lift f g).range = f.range ⊔ g.range

full_name: AddMonoid.Coprod.range_lift
code: @[to_additive (attr := simp)] theorem range_lift (f : G →* K) (g : H →* K) :
    MonoidHom.range (lift f g) = MonoidHom.range f ⊔ MonoidHom.range g 
goal: (AddMonoid.Coprod.lift f g).range = f.range ⊔ g.range

full_name: Monoid.MulEquiv.coprodCongr
code: /-- Lift two monoid equivalences `e : M ≃* N` and `e' : M' ≃* N'` to a monoid equivalence
`(M ∗ M') ≃* (N ∗ N')`. -/
@[to_additive (attr := simps! (config := .asFn)) "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')`."]
def coprodCongr (e : M ≃* N) (e' : M' ≃* N') : (M ∗ M') ≃* (N ∗ N') 
goal: Monoid.Coprod M M' ≃* Monoid.Coprod N N'

full_name: AddMonoid.MulEquiv.coprodCongr_apply
code: /-- Lift two monoid equivalences `e : M ≃* N` and `e' : M' ≃* N'` to a monoid equivalence
`(M ∗ M') ≃* (N ∗ N')`. -/
@[to_additive (attr := simps! (config := .asFn)) "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')`."]
def coprodCongr (e : M ≃* N) (e' : M' ≃* N') : (M ∗ M') ≃* (N ∗ N') 
goal: ⇑(AddMonoid.MulEquiv.coprodCongr e e') = ⇑(AddMonoid.Coprod.map ↑e ↑e')

full_name: AddMonoid.MulEquiv.coprodCongr_symm_apply
code: /-- Lift two monoid equivalences `e : M ≃* N` and `e' : M' ≃* N'` to a monoid equivalence
`(M ∗ M') ≃* (N ∗ N')`. -/
@[to_additive (attr := simps! (config := .asFn)) "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')`."]
def coprodCongr (e : M ≃* N) (e' : M' ≃* N') : (M ∗ M') ≃* (N ∗ N') 
goal: ⇑(AddMonoid.MulEquiv.coprodCongr e e').symm = ⇑(AddMonoid.Coprod.map ↑e.symm ↑e'.symm)

full_name: Monoid.MulEquiv.coprodCongr_symm_apply
code: /-- Lift two monoid equivalences `e : M ≃* N` and `e' : M' ≃* N'` to a monoid equivalence
`(M ∗ M') ≃* (N ∗ N')`. -/
@[to_additive (attr := simps! (config := .asFn)) "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')`."]
def coprodCongr (e : M ≃* N) (e' : M' ≃* N') : (M ∗ M') ≃* (N ∗ N') 
goal: ⇑(Monoid.MulEquiv.coprodCongr e e').symm = ⇑(Monoid.Coprod.map ↑e.symm ↑e'.symm)

full_name: Monoid.MulEquiv.coprodCongr_apply
code: /-- Lift two monoid equivalences `e : M ≃* N` and `e' : M' ≃* N'` to a monoid equivalence
`(M ∗ M') ≃* (N ∗ N')`. -/
@[to_additive (attr := simps! (config := .asFn)) "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')`."]
def coprodCongr (e : M ≃* N) (e' : M' ≃* N') : (M ∗ M') ≃* (N ∗ N') 
goal: ⇑(Monoid.MulEquiv.coprodCongr e e') = ⇑(Monoid.Coprod.map ↑e ↑e')

full_name: AddMonoid.MulEquiv.coprodCongr
code: /-- Lift two monoid equivalences `e : M ≃* N` and `e' : M' ≃* N'` to a monoid equivalence
`(M ∗ M') ≃* (N ∗ N')`. -/
@[to_additive (attr := simps! (config := .asFn)) "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')`."]
def coprodCongr (e : M ≃* N) (e' : M' ≃* N') : (M ∗ M') ≃* (N ∗ N') 
goal: AddMonoid.Coprod M M' ≃+ AddMonoid.Coprod N N'

full_name: AddMonoid.MulEquiv.coprodComm_apply
code: /-- A `MulEquiv` version of `Coprod.swap`. -/
@[to_additive (attr := simps! (config := .asFn))
  "An `AddEquiv` version of `AddMonoid.Coprod.swap`."]
def coprodComm : M ∗ N ≃* N ∗ M 
goal: ⇑(AddMonoid.MulEquiv.coprodComm M N) = ⇑(AddMonoid.Coprod.swap M N)

full_name: Monoid.MulEquiv.coprodComm
code: /-- A `MulEquiv` version of `Coprod.swap`. -/
@[to_additive (attr := simps! (config := .asFn))
  "An `AddEquiv` version of `AddMonoid.Coprod.swap`."]
def coprodComm : M ∗ N ≃* N ∗ M 
goal: Monoid.Coprod M N ≃* Monoid.Coprod N M

full_name: AddMonoid.MulEquiv.coprodComm_symm_apply
code: /-- A `MulEquiv` version of `Coprod.swap`. -/
@[to_additive (attr := simps! (config := .asFn))
  "An `AddEquiv` version of `AddMonoid.Coprod.swap`."]
def coprodComm : M ∗ N ≃* N ∗ M 
goal: ⇑(AddMonoid.MulEquiv.coprodComm M N).symm = ⇑(AddMonoid.Coprod.swap N M)

full_name: Monoid.MulEquiv.coprodComm_symm_apply
code: /-- A `MulEquiv` version of `Coprod.swap`. -/
@[to_additive (attr := simps! (config := .asFn))
  "An `AddEquiv` version of `AddMonoid.Coprod.swap`."]
def coprodComm : M ∗ N ≃* N ∗ M 
goal: ⇑(Monoid.MulEquiv.coprodComm M N).symm = ⇑(Monoid.Coprod.swap N M)

full_name: AddMonoid.MulEquiv.coprodComm
code: /-- A `MulEquiv` version of `Coprod.swap`. -/
@[to_additive (attr := simps! (config := .asFn))
  "An `AddEquiv` version of `AddMonoid.Coprod.swap`."]
def coprodComm : M ∗ N ≃* N ∗ M 
goal: AddMonoid.Coprod M N ≃+ AddMonoid.Coprod N M

full_name: Monoid.MulEquiv.coprodComm_apply
code: /-- A `MulEquiv` version of `Coprod.swap`. -/
@[to_additive (attr := simps! (config := .asFn))
  "An `AddEquiv` version of `AddMonoid.Coprod.swap`."]
def coprodComm : M ∗ N ≃* N ∗ M 
goal: ⇑(Monoid.MulEquiv.coprodComm M N) = ⇑(Monoid.Coprod.swap M N)

full_name: AddMonoid.MulEquiv.coprodAssoc
code: /-- A multiplicative equivalence between `(M ∗ N) ∗ P` and `M ∗ (N ∗ P)`. -/
@[to_additive "An additive equivalence between `AddMonoid.Coprod (AddMonoid.Coprod M N) P` and
`AddMonoid.Coprod M (AddMonoid.Coprod N P)`."]
def coprodAssoc : (M ∗ N) ∗ P ≃* M ∗ (N ∗ P) 
goal: AddMonoid.Coprod (AddMonoid.Coprod M N) P ≃+ AddMonoid.Coprod M (AddMonoid.Coprod N P)

full_name: Monoid.MulEquiv.coprodAssoc
code: /-- A multiplicative equivalence between `(M ∗ N) ∗ P` and `M ∗ (N ∗ P)`. -/
@[to_additive "An additive equivalence between `AddMonoid.Coprod (AddMonoid.Coprod M N) P` and
`AddMonoid.Coprod M (AddMonoid.Coprod N P)`."]
def coprodAssoc : (M ∗ N) ∗ P ≃* M ∗ (N ∗ P) 
goal: Monoid.Coprod (Monoid.Coprod M N) P ≃* Monoid.Coprod M (Monoid.Coprod N P)

full_name: AddMonoid.MulEquiv.coprodAssoc_apply_inl_inl
code: @[to_additive (attr := simp)]
theorem coprodAssoc_apply_inl_inl (x : M) : coprodAssoc M N P (inl (inl x)) = inl x 
goal: (AddMonoid.MulEquiv.coprodAssoc M N P) (AddMonoid.Coprod.inl (AddMonoid.Coprod.inl x)) = AddMonoid.Coprod.inl x

full_name: Monoid.MulEquiv.coprodAssoc_apply_inl_inl
code: @[to_additive (attr := simp)]
theorem coprodAssoc_apply_inl_inl (x : M) : coprodAssoc M N P (inl (inl x)) = inl x 
goal: (Monoid.MulEquiv.coprodAssoc M N P) (Monoid.Coprod.inl (Monoid.Coprod.inl x)) = Monoid.Coprod.inl x

full_name: Monoid.MulEquiv.coprodAssoc_apply_inl_inr
code: @[to_additive (attr := simp)]
theorem coprodAssoc_apply_inl_inr (x : N) : coprodAssoc M N P (inl (inr x)) = inr (inl x) 
goal: (Monoid.MulEquiv.coprodAssoc M N P) (Monoid.Coprod.inl (Monoid.Coprod.inr x)) = Monoid.Coprod.inr (Monoid.Coprod.inl x)

full_name: AddMonoid.MulEquiv.coprodAssoc_apply_inl_inr
code: @[to_additive (attr := simp)]
theorem coprodAssoc_apply_inl_inr (x : N) : coprodAssoc M N P (inl (inr x)) = inr (inl x) 
goal: (AddMonoid.MulEquiv.coprodAssoc M N P) (AddMonoid.Coprod.inl (AddMonoid.Coprod.inr x)) =
  AddMonoid.Coprod.inr (AddMonoid.Coprod.inl x)

full_name: AddMonoid.MulEquiv.coprodAssoc_apply_inr
code: @[to_additive (attr := simp)]
theorem coprodAssoc_apply_inr (x : P) : coprodAssoc M N P (inr x) = inr (inr x) 
goal: (AddMonoid.MulEquiv.coprodAssoc M N P) (AddMonoid.Coprod.inr x) = AddMonoid.Coprod.inr (AddMonoid.Coprod.inr x)

full_name: Monoid.MulEquiv.coprodAssoc_apply_inr
code: @[to_additive (attr := simp)]
theorem coprodAssoc_apply_inr (x : P) : coprodAssoc M N P (inr x) = inr (inr x) 
goal: (Monoid.MulEquiv.coprodAssoc M N P) (Monoid.Coprod.inr x) = Monoid.Coprod.inr (Monoid.Coprod.inr x)

full_name: Monoid.MulEquiv.coprodAssoc_symm_apply_inl
code: @[to_additive (attr := simp)]
theorem coprodAssoc_symm_apply_inl (x : M) : (coprodAssoc M N P).symm (inl x) = inl (inl x) 
goal: (Monoid.MulEquiv.coprodAssoc M N P).symm (Monoid.Coprod.inl x) = Monoid.Coprod.inl (Monoid.Coprod.inl x)

full_name: AddMonoid.MulEquiv.coprodAssoc_symm_apply_inl
code: @[to_additive (attr := simp)]
theorem coprodAssoc_symm_apply_inl (x : M) : (coprodAssoc M N P).symm (inl x) = inl (inl x) 
goal: (AddMonoid.MulEquiv.coprodAssoc M N P).symm (AddMonoid.Coprod.inl x) = AddMonoid.Coprod.inl (AddMonoid.Coprod.inl x)

full_name: Monoid.MulEquiv.coprodAssoc_symm_apply_inr_inl
code: @[to_additive (attr := simp)]
theorem coprodAssoc_symm_apply_inr_inl (x : N) :
    (coprodAssoc M N P).symm (inr (inl x)) = inl (inr x) 
goal: (Monoid.MulEquiv.coprodAssoc M N P).symm (Monoid.Coprod.inr (Monoid.Coprod.inl x)) =
  Monoid.Coprod.inl (Monoid.Coprod.inr x)

full_name: AddMonoid.MulEquiv.coprodAssoc_symm_apply_inr_inl
code: @[to_additive (attr := simp)]
theorem coprodAssoc_symm_apply_inr_inl (x : N) :
    (coprodAssoc M N P).symm (inr (inl x)) = inl (inr x) 
goal: (AddMonoid.MulEquiv.coprodAssoc M N P).symm (AddMonoid.Coprod.inr (AddMonoid.Coprod.inl x)) =
  AddMonoid.Coprod.inl (AddMonoid.Coprod.inr x)

full_name: AddMonoid.MulEquiv.coprodAssoc_symm_apply_inr_inr
code: @[to_additive (attr := simp)]
theorem coprodAssoc_symm_apply_inr_inr (x : P) :
    (coprodAssoc M N P).symm (inr (inr x)) = inr x 
goal: (AddMonoid.MulEquiv.coprodAssoc M N P).symm (AddMonoid.Coprod.inr (AddMonoid.Coprod.inr x)) = AddMonoid.Coprod.inr x

full_name: Monoid.MulEquiv.coprodAssoc_symm_apply_inr_inr
code: @[to_additive (attr := simp)]
theorem coprodAssoc_symm_apply_inr_inr (x : P) :
    (coprodAssoc M N P).symm (inr (inr x)) = inr x 
goal: (Monoid.MulEquiv.coprodAssoc M N P).symm (Monoid.Coprod.inr (Monoid.Coprod.inr x)) = Monoid.Coprod.inr x

full_name: Monoid.MulEquiv.coprodPUnit_apply
code: /-- Isomorphism between `M ∗ PUnit` and `M`. -/
@[simps! (config := .asFn)]
def coprodPUnit : M ∗ PUnit ≃* M 
goal: ⇑(Monoid.MulEquiv.coprodPUnit M) = ⇑Monoid.Coprod.fst

full_name: Monoid.MulEquiv.coprodPUnit
code: /-- Isomorphism between `M ∗ PUnit` and `M`. -/
@[simps! (config := .asFn)]
def coprodPUnit : M ∗ PUnit ≃* M 
goal: Monoid.Coprod M PUnit.{u_4 + 1} ≃* M

full_name: Monoid.MulEquiv.coprodPUnit_symm_apply
code: /-- Isomorphism between `M ∗ PUnit` and `M`. -/
@[simps! (config := .asFn)]
def coprodPUnit : M ∗ PUnit ≃* M 
goal: ⇑(Monoid.MulEquiv.coprodPUnit M).symm = ⇑Monoid.Coprod.inl

full_name: Monoid.MulEquiv.punitCoprod_apply
code: /-- Isomorphism between `PUnit ∗ M` and `M`. -/
@[simps! (config := .asFn)]
def punitCoprod : PUnit ∗ M ≃* M 
goal: ⇑(Monoid.MulEquiv.punitCoprod M) = ⇑Monoid.Coprod.snd

full_name: Monoid.MulEquiv.punitCoprod_symm_apply
code: /-- Isomorphism between `PUnit ∗ M` and `M`. -/
@[simps! (config := .asFn)]
def punitCoprod : PUnit ∗ M ≃* M 
goal: ⇑(Monoid.MulEquiv.punitCoprod M).symm = ⇑Monoid.Coprod.inr

full_name: Monoid.MulEquiv.punitCoprod
code: /-- Isomorphism between `PUnit ∗ M` and `M`. -/
@[simps! (config := .asFn)]
def punitCoprod : PUnit ∗ M ≃* M 
goal: Monoid.Coprod PUnit.{u_4 + 1} M ≃* M

full_name: Monoid.AddEquiv.coprodUnit_apply
code: /-- Isomorphism between `M ∗ PUnit` and `M`. -/
@[simps! (config := .asFn)]
def coprodUnit : AddMonoid.Coprod M PUnit ≃+ M 
goal: ⇑Monoid.AddEquiv.coprodUnit = ⇑AddMonoid.Coprod.fst

full_name: Monoid.AddEquiv.coprodUnit_symm_apply
code: /-- Isomorphism between `M ∗ PUnit` and `M`. -/
@[simps! (config := .asFn)]
def coprodUnit : AddMonoid.Coprod M PUnit ≃+ M 
goal: ⇑Monoid.AddEquiv.coprodUnit.symm = ⇑AddMonoid.Coprod.inl

full_name: Monoid.AddEquiv.coprodUnit
code: /-- Isomorphism between `M ∗ PUnit` and `M`. -/
@[simps! (config := .asFn)]
def coprodUnit : AddMonoid.Coprod M PUnit ≃+ M 
goal: AddMonoid.Coprod M PUnit.{u_2 + 1} ≃+ M

full_name: Monoid.AddEquiv.punitCoprod_symm_apply
code: /-- Isomorphism between `PUnit ∗ M` and `M`. -/
@[simps! (config := .asFn)]
def punitCoprod : AddMonoid.Coprod PUnit M ≃+ M 
goal: ⇑Monoid.AddEquiv.punitCoprod.symm = ⇑AddMonoid.Coprod.inr

full_name: Monoid.AddEquiv.punitCoprod_apply
code: /-- Isomorphism between `PUnit ∗ M` and `M`. -/
@[simps! (config := .asFn)]
def punitCoprod : AddMonoid.Coprod PUnit M ≃+ M 
goal: ⇑Monoid.AddEquiv.punitCoprod = ⇑AddMonoid.Coprod.snd

full_name: Monoid.AddEquiv.punitCoprod
code: /-- Isomorphism between `PUnit ∗ M` and `M`. -/
@[simps! (config := .asFn)]
def punitCoprod : AddMonoid.Coprod PUnit M ≃+ M 
goal: AddMonoid.Coprod PUnit.{u_2 + 1} M ≃+ M