File: Mathlib/Algebra/Group/Prod.lean

full_name: Prod.instMul
code: @[to_additive]
instance instMul [Mul M] [Mul N] : Mul (M × N) 
goal: Mul (M × N)

full_name: Prod.instAdd
code: @[to_additive]
instance instMul [Mul M] [Mul N] : Mul (M × N) 
goal: Add (M × N)

full_name: Prod.fst_add
code: @[to_additive (attr := simp)]
theorem fst_mul [Mul M] [Mul N] (p q : M × N) : (p * q).1 = p.1 * q.1 
goal: (p + q).1 = p.1 + q.1

full_name: Prod.fst_mul
code: @[to_additive (attr := simp)]
theorem fst_mul [Mul M] [Mul N] (p q : M × N) : (p * q).1 = p.1 * q.1 
goal: (p * q).1 = p.1 * q.1

full_name: Prod.snd_mul
code: @[to_additive (attr := simp)]
theorem snd_mul [Mul M] [Mul N] (p q : M × N) : (p * q).2 = p.2 * q.2 
goal: (p * q).2 = p.2 * q.2

full_name: Prod.snd_add
code: @[to_additive (attr := simp)]
theorem snd_mul [Mul M] [Mul N] (p q : M × N) : (p * q).2 = p.2 * q.2 
goal: (p + q).2 = p.2 + q.2

full_name: Prod.mk_mul_mk
code: @[to_additive (attr := simp)]
theorem mk_mul_mk [Mul M] [Mul N] (a₁ a₂ : M) (b₁ b₂ : N) :
    (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂) 
goal: (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂)

full_name: Prod.mk_add_mk
code: @[to_additive (attr := simp)]
theorem mk_mul_mk [Mul M] [Mul N] (a₁ a₂ : M) (b₁ b₂ : N) :
    (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂) 
goal: (a₁, b₁) + (a₂, b₂) = (a₁ + a₂, b₁ + b₂)

full_name: Prod.swap_mul
code: @[to_additive (attr := simp)]
theorem swap_mul [Mul M] [Mul N] (p q : M × N) : (p * q).swap = p.swap * q.swap 
goal: (p * q).swap = p.swap * q.swap

full_name: Prod.swap_add
code: @[to_additive (attr := simp)]
theorem swap_mul [Mul M] [Mul N] (p q : M × N) : (p * q).swap = p.swap * q.swap 
goal: (p + q).swap = p.swap + q.swap

full_name: Prod.add_def
code: @[to_additive]
theorem mul_def [Mul M] [Mul N] (p q : M × N) : p * q = (p.1 * q.1, p.2 * q.2) 
goal: p + q = (p.1 + q.1, p.2 + q.2)

full_name: Prod.mul_def
code: @[to_additive]
theorem mul_def [Mul M] [Mul N] (p q : M × N) : p * q = (p.1 * q.1, p.2 * q.2) 
goal: p * q = (p.1 * q.1, p.2 * q.2)

full_name: Prod.zero_mk_add_zero_mk
code: @[to_additive]
theorem one_mk_mul_one_mk [Monoid M] [Mul N] (b₁ b₂ : N) :
    ((1 : M), b₁) * (1, b₂) = (1, b₁ * b₂) 
goal: (0, b₁) + (0, b₂) = (0, b₁ + b₂)

full_name: Prod.one_mk_mul_one_mk
code: @[to_additive]
theorem one_mk_mul_one_mk [Monoid M] [Mul N] (b₁ b₂ : N) :
    ((1 : M), b₁) * (1, b₂) = (1, b₁ * b₂) 
goal: (1, b₁) * (1, b₂) = (1, b₁ * b₂)

full_name: Prod.mk_zero_add_mk_zero
code: @[to_additive]
theorem mk_one_mul_mk_one [Mul M] [Monoid N] (a₁ a₂ : M) :
    (a₁, (1 : N)) * (a₂, 1) = (a₁ * a₂, 1) 
goal: (a₁, 0) + (a₂, 0) = (a₁ + a₂, 0)

full_name: Prod.mk_one_mul_mk_one
code: @[to_additive]
theorem mk_one_mul_mk_one [Mul M] [Monoid N] (a₁ a₂ : M) :
    (a₁, (1 : N)) * (a₂, 1) = (a₁ * a₂, 1) 
goal: (a₁, 1) * (a₂, 1) = (a₁ * a₂, 1)

full_name: Prod.instZero
code: @[to_additive]
instance instOne [One M] [One N] : One (M × N) 
goal: Zero (M × N)

full_name: Prod.instOne
code: @[to_additive]
instance instOne [One M] [One N] : One (M × N) 
goal: One (M × N)

full_name: Prod.fst_one
code: @[to_additive (attr := simp)]
theorem fst_one [One M] [One N] : (1 : M × N).1 = 1 
goal: 1.1 = 1

full_name: Prod.fst_zero
code: @[to_additive (attr := simp)]
theorem fst_one [One M] [One N] : (1 : M × N).1 = 1 
goal: 0.1 = 0

full_name: Prod.snd_one
code: @[to_additive (attr := simp)]
theorem snd_one [One M] [One N] : (1 : M × N).2 = 1 
goal: 1.2 = 1

full_name: Prod.snd_zero
code: @[to_additive (attr := simp)]
theorem snd_one [One M] [One N] : (1 : M × N).2 = 1 
goal: 0.2 = 0

full_name: Prod.zero_eq_mk
code: @[to_additive]
theorem one_eq_mk [One M] [One N] : (1 : M × N) = (1, 1) 
goal: 0 = (0, 0)

full_name: Prod.one_eq_mk
code: @[to_additive]
theorem one_eq_mk [One M] [One N] : (1 : M × N) = (1, 1) 
goal: 1 = (1, 1)

full_name: Prod.mk_eq_one
code: @[to_additive (attr := simp)]
theorem mk_eq_one [One M] [One N] {x : M} {y : N} : (x, y) = 1 ↔ x = 1 ∧ y = 1 
goal: (x, y) = 1 ↔ x = 1 ∧ y = 1

full_name: Prod.mk_eq_zero
code: @[to_additive (attr := simp)]
theorem mk_eq_one [One M] [One N] {x : M} {y : N} : (x, y) = 1 ↔ x = 1 ∧ y = 1 
goal: (x, y) = 0 ↔ x = 0 ∧ y = 0

full_name: Prod.swap_one
code: @[to_additive (attr := simp)]
theorem swap_one [One M] [One N] : (1 : M × N).swap = 1 
goal: Prod.swap 1 = 1

full_name: Prod.swap_zero
code: @[to_additive (attr := simp)]
theorem swap_one [One M] [One N] : (1 : M × N).swap = 1 
goal: Prod.swap 0 = 0

full_name: Prod.fst_mul_snd
code: @[to_additive]
theorem fst_mul_snd [MulOneClass M] [MulOneClass N] (p : M × N) : (p.fst, 1) * (1, p.snd) = p 
goal: (p.1, 1) * (1, p.2) = p

full_name: Prod.fst_add_snd
code: @[to_additive]
theorem fst_mul_snd [MulOneClass M] [MulOneClass N] (p : M × N) : (p.fst, 1) * (1, p.snd) = p 
goal: (p.1, 0) + (0, p.2) = p

full_name: Prod.instNeg
code: @[to_additive]
instance instInv [Inv M] [Inv N] : Inv (M × N) 
goal: Neg (M × N)

full_name: Prod.instInv
code: @[to_additive]
instance instInv [Inv M] [Inv N] : Inv (M × N) 
goal: Inv (M × N)

full_name: Prod.fst_inv
code: @[to_additive (attr := simp)]
theorem fst_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.1 = p.1⁻¹ 
goal: p⁻¹.1 = p.1⁻¹

full_name: Prod.fst_neg
code: @[to_additive (attr := simp)]
theorem fst_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.1 = p.1⁻¹ 
goal: (-p).1 = -p.1

full_name: Prod.snd_neg
code: @[to_additive (attr := simp)]
theorem snd_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.2 = p.2⁻¹ 
goal: (-p).2 = -p.2

full_name: Prod.snd_inv
code: @[to_additive (attr := simp)]
theorem snd_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.2 = p.2⁻¹ 
goal: p⁻¹.2 = p.2⁻¹

full_name: Prod.neg_mk
code: @[to_additive (attr := simp)]
theorem inv_mk [Inv G] [Inv H] (a : G) (b : H) : (a, b)⁻¹ = (a⁻¹, b⁻¹) 
goal: -(a, b) = (-a, -b)

full_name: Prod.inv_mk
code: @[to_additive (attr := simp)]
theorem inv_mk [Inv G] [Inv H] (a : G) (b : H) : (a, b)⁻¹ = (a⁻¹, b⁻¹) 
goal: (a, b)⁻¹ = (a⁻¹, b⁻¹)

full_name: Prod.swap_neg
code: @[to_additive (attr := simp)]
theorem swap_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.swap = p.swap⁻¹ 
goal: (-p).swap = -p.swap

full_name: Prod.swap_inv
code: @[to_additive (attr := simp)]
theorem swap_inv [Inv G] [Inv H] (p : G × H) : p⁻¹.swap = p.swap⁻¹ 
goal: p⁻¹.swap = p.swap⁻¹

full_name: Prod.instInvolutiveInv
code: @[to_additive]
instance [InvolutiveInv M] [InvolutiveInv N] : InvolutiveInv (M × N) 
goal: InvolutiveInv (M × N)

full_name: Prod.instInvolutiveNeg
code: @[to_additive]
instance [InvolutiveInv M] [InvolutiveInv N] : InvolutiveInv (M × N) 
goal: InvolutiveNeg (M × N)

full_name: Prod.instSub
code: @[to_additive]
instance instDiv [Div M] [Div N] : Div (M × N) 
goal: Sub (M × N)

full_name: Prod.instDiv
code: @[to_additive]
instance instDiv [Div M] [Div N] : Div (M × N) 
goal: Div (M × N)

full_name: Prod.fst_div
code: @[to_additive (attr := simp)]
theorem fst_div [Div G] [Div H] (a b : G × H) : (a / b).1 = a.1 / b.1 
goal: (a / b).1 = a.1 / b.1

full_name: Prod.fst_sub
code: @[to_additive (attr := simp)]
theorem fst_div [Div G] [Div H] (a b : G × H) : (a / b).1 = a.1 / b.1 
goal: (a - b).1 = a.1 - b.1

full_name: Prod.snd_div
code: @[to_additive (attr := simp)]
theorem snd_div [Div G] [Div H] (a b : G × H) : (a / b).2 = a.2 / b.2 
goal: (a / b).2 = a.2 / b.2

full_name: Prod.snd_sub
code: @[to_additive (attr := simp)]
theorem snd_div [Div G] [Div H] (a b : G × H) : (a / b).2 = a.2 / b.2 
goal: (a - b).2 = a.2 - b.2

full_name: Prod.mk_sub_mk
code: @[to_additive (attr := simp)]
theorem mk_div_mk [Div G] [Div H] (x₁ x₂ : G) (y₁ y₂ : H) :
    (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂) 
goal: (x₁, y₁) - (x₂, y₂) = (x₁ - x₂, y₁ - y₂)

full_name: Prod.mk_div_mk
code: @[to_additive (attr := simp)]
theorem mk_div_mk [Div G] [Div H] (x₁ x₂ : G) (y₁ y₂ : H) :
    (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂) 
goal: (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂)

full_name: Prod.swap_sub
code: @[to_additive (attr := simp)]
theorem swap_div [Div G] [Div H] (a b : G × H) : (a / b).swap = a.swap / b.swap 
goal: (a - b).swap = a.swap - b.swap

full_name: Prod.swap_div
code: @[to_additive (attr := simp)]
theorem swap_div [Div G] [Div H] (a b : G × H) : (a / b).swap = a.swap / b.swap 
goal: (a / b).swap = a.swap / b.swap

full_name: Prod.instSemigroup
code: @[to_additive]
instance instSemigroup [Semigroup M] [Semigroup N] : Semigroup (M × N) 
goal: Semigroup (M × N)

full_name: Prod.instAddSemigroup
code: @[to_additive]
instance instSemigroup [Semigroup M] [Semigroup N] : Semigroup (M × N) 
goal: AddSemigroup (M × N)

full_name: Prod.instAddCommSemigroup
code: @[to_additive]
instance instCommSemigroup [CommSemigroup G] [CommSemigroup H] : CommSemigroup (G × H) 
goal: AddCommSemigroup (G × H)

full_name: Prod.instCommSemigroup
code: @[to_additive]
instance instCommSemigroup [CommSemigroup G] [CommSemigroup H] : CommSemigroup (G × H) 
goal: CommSemigroup (G × H)

full_name: Prod.instAddZeroClass
code: @[to_additive]
instance instMulOneClass [MulOneClass M] [MulOneClass N] : MulOneClass (M × N) 
goal: AddZeroClass (M × N)

full_name: Prod.instMulOneClass
code: @[to_additive]
instance instMulOneClass [MulOneClass M] [MulOneClass N] : MulOneClass (M × N) 
goal: MulOneClass (M × N)

full_name: Prod.instAddMonoid
code: @[to_additive]
instance instMonoid [Monoid M] [Monoid N] : Monoid (M × N) 
goal: AddMonoid (M × N)

full_name: Prod.instMonoid
code: @[to_additive]
instance instMonoid [Monoid M] [Monoid N] : Monoid (M × N) 
goal: Monoid (M × N)

full_name: Prod.instDivInvMonoid
code: @[to_additive Prod.subNegMonoid]
instance [DivInvMonoid G] [DivInvMonoid H] : DivInvMonoid (G × H) 
goal: DivInvMonoid (G × H)

full_name: Prod.subNegMonoid
code: @[to_additive Prod.subNegMonoid]
instance [DivInvMonoid G] [DivInvMonoid H] : DivInvMonoid (G × H) 
goal: SubNegMonoid (G × H)

full_name: Prod.instDivisionAddMonoid
code: @[to_additive]
instance [DivisionMonoid G] [DivisionMonoid H] : DivisionMonoid (G × H) 
goal: SubtractionMonoid (G × H)

full_name: Prod.instDivisionMonoid
code: @[to_additive]
instance [DivisionMonoid G] [DivisionMonoid H] : DivisionMonoid (G × H) 
goal: DivisionMonoid (G × H)

full_name: Prod.instDivisionCommMonoid
code: @[to_additive SubtractionCommMonoid]
instance [DivisionCommMonoid G] [DivisionCommMonoid H] : DivisionCommMonoid (G × H) 
goal: DivisionCommMonoid (G × H)

full_name: Prod.SubtractionCommMonoid
code: @[to_additive SubtractionCommMonoid]
instance [DivisionCommMonoid G] [DivisionCommMonoid H] : DivisionCommMonoid (G × H) 
goal: SubtractionCommMonoid (G × H)

full_name: Prod.instGroup
code: @[to_additive]
instance instGroup [Group G] [Group H] : Group (G × H) 
goal: Group (G × H)

full_name: Prod.instAddGroup
code: @[to_additive]
instance instGroup [Group G] [Group H] : Group (G × H) 
goal: AddGroup (G × H)

full_name: Prod.instIsAddLeftCancel
code: @[to_additive]
instance [Mul G] [Mul H] [IsLeftCancelMul G] [IsLeftCancelMul H] : IsLeftCancelMul (G × H) 
goal: IsLeftCancelAdd (G × H)

full_name: Prod.instIsLeftCancelMul
code: @[to_additive]
instance [Mul G] [Mul H] [IsLeftCancelMul G] [IsLeftCancelMul H] : IsLeftCancelMul (G × H) 
goal: IsLeftCancelMul (G × H)

full_name: Prod.instIsAddRightCancel
code: @[to_additive]
instance [Mul G] [Mul H] [IsRightCancelMul G] [IsRightCancelMul H] : IsRightCancelMul (G × H) 
goal: IsRightCancelAdd (G × H)

full_name: Prod.instIsRightCancelMul
code: @[to_additive]
instance [Mul G] [Mul H] [IsRightCancelMul G] [IsRightCancelMul H] : IsRightCancelMul (G × H) 
goal: IsRightCancelMul (G × H)

full_name: Prod.instIsCancelMul
code: @[to_additive]
instance [Mul G] [Mul H] [IsCancelMul G] [IsCancelMul H] : IsCancelMul (G × H) 
goal: IsCancelMul (G × H)

full_name: Prod.instIsAddCancel
code: @[to_additive]
instance [Mul G] [Mul H] [IsCancelMul G] [IsCancelMul H] : IsCancelMul (G × H) 
goal: IsCancelAdd (G × H)

full_name: Prod.instAddLeftCancelSemigroup
code: @[to_additive]
instance [LeftCancelSemigroup G] [LeftCancelSemigroup H] : LeftCancelSemigroup (G × H) 
goal: AddLeftCancelSemigroup (G × H)

full_name: Prod.instLeftCancelSemigroup
code: @[to_additive]
instance [LeftCancelSemigroup G] [LeftCancelSemigroup H] : LeftCancelSemigroup (G × H) 
goal: LeftCancelSemigroup (G × H)

full_name: Prod.instAddRightCancelSemigroup
code: @[to_additive]
instance [RightCancelSemigroup G] [RightCancelSemigroup H] : RightCancelSemigroup (G × H) 
goal: AddRightCancelSemigroup (G × H)

full_name: Prod.instRightCancelSemigroup
code: @[to_additive]
instance [RightCancelSemigroup G] [RightCancelSemigroup H] : RightCancelSemigroup (G × H) 
goal: RightCancelSemigroup (G × H)

full_name: Prod.instLeftCancelMonoid
code: @[to_additive]
instance [LeftCancelMonoid M] [LeftCancelMonoid N] : LeftCancelMonoid (M × N) 
goal: LeftCancelMonoid (M × N)

full_name: Prod.instAddLeftCancelMonoid
code: @[to_additive]
instance [LeftCancelMonoid M] [LeftCancelMonoid N] : LeftCancelMonoid (M × N) 
goal: AddLeftCancelMonoid (M × N)

full_name: Prod.instAddRightCancelMonoid
code: @[to_additive]
instance [RightCancelMonoid M] [RightCancelMonoid N] : RightCancelMonoid (M × N) 
goal: AddRightCancelMonoid (M × N)

full_name: Prod.instRightCancelMonoid
code: @[to_additive]
instance [RightCancelMonoid M] [RightCancelMonoid N] : RightCancelMonoid (M × N) 
goal: RightCancelMonoid (M × N)

full_name: Prod.instCancelMonoid
code: @[to_additive]
instance [CancelMonoid M] [CancelMonoid N] : CancelMonoid (M × N) 
goal: CancelMonoid (M × N)

full_name: Prod.instAddCancelMonoid
code: @[to_additive]
instance [CancelMonoid M] [CancelMonoid N] : CancelMonoid (M × N) 
goal: AddCancelMonoid (M × N)

full_name: Prod.instAddCommMonoid
code: @[to_additive]
instance instCommMonoid [CommMonoid M] [CommMonoid N] : CommMonoid (M × N) 
goal: AddCommMonoid (M × N)

full_name: Prod.instCommMonoid
code: @[to_additive]
instance instCommMonoid [CommMonoid M] [CommMonoid N] : CommMonoid (M × N) 
goal: CommMonoid (M × N)

full_name: Prod.instAddCancelCommMonoid
code: @[to_additive]
instance [CancelCommMonoid M] [CancelCommMonoid N] : CancelCommMonoid (M × N) 
goal: AddCancelCommMonoid (M × N)

full_name: Prod.instCancelCommMonoid
code: @[to_additive]
instance [CancelCommMonoid M] [CancelCommMonoid N] : CancelCommMonoid (M × N) 
goal: CancelCommMonoid (M × N)

full_name: Prod.instAddCommGroup
code: @[to_additive]
instance instCommGroup [CommGroup G] [CommGroup H] : CommGroup (G × H) 
goal: AddCommGroup (G × H)

full_name: Prod.instCommGroup
code: @[to_additive]
instance instCommGroup [CommGroup G] [CommGroup H] : CommGroup (G × H) 
goal: CommGroup (G × H)

full_name: SemiconjBy.prod
code: @[to_additive AddSemiconjBy.prod]
theorem SemiconjBy.prod {x y z : M × N}
    (hm : SemiconjBy x.1 y.1 z.1) (hn : SemiconjBy x.2 y.2 z.2) : SemiconjBy x y z 
goal: SemiconjBy x y z

full_name: AddSemiconjBy.prod
code: @[to_additive AddSemiconjBy.prod]
theorem SemiconjBy.prod {x y z : M × N}
    (hm : SemiconjBy x.1 y.1 z.1) (hn : SemiconjBy x.2 y.2 z.2) : SemiconjBy x y z 
goal: AddSemiconjBy x y z

full_name: Prod.addSemiconjBy_iff
code: @[to_additive]
theorem Prod.semiconjBy_iff {x y z : M × N} :
    SemiconjBy x y z ↔ SemiconjBy x.1 y.1 z.1 ∧ SemiconjBy x.2 y.2 z.2 
goal: AddSemiconjBy x y z ↔ AddSemiconjBy x.1 y.1 z.1 ∧ AddSemiconjBy x.2 y.2 z.2

full_name: Prod.semiconjBy_iff
code: @[to_additive]
theorem Prod.semiconjBy_iff {x y z : M × N} :
    SemiconjBy x y z ↔ SemiconjBy x.1 y.1 z.1 ∧ SemiconjBy x.2 y.2 z.2 
goal: SemiconjBy x y z ↔ SemiconjBy x.1 y.1 z.1 ∧ SemiconjBy x.2 y.2 z.2

full_name: AddCommute.prod
code: @[to_additive AddCommute.prod]
theorem Commute.prod {x y : M × N} (hm : Commute x.1 y.1) (hn : Commute x.2 y.2) : Commute x y 
goal: AddCommute x y

full_name: Commute.prod
code: @[to_additive AddCommute.prod]
theorem Commute.prod {x y : M × N} (hm : Commute x.1 y.1) (hn : Commute x.2 y.2) : Commute x y 
goal: Commute x y

full_name: Prod.addCommute_iff
code: @[to_additive]
theorem Prod.commute_iff {x y : M × N} :
    Commute x y ↔ Commute x.1 y.1 ∧ Commute x.2 y.2 
goal: AddCommute x y ↔ AddCommute x.1 y.1 ∧ AddCommute x.2 y.2

full_name: Prod.commute_iff
code: @[to_additive]
theorem Prod.commute_iff {x y : M × N} :
    Commute x y ↔ Commute x.1 y.1 ∧ Commute x.2 y.2 
goal: Commute x y ↔ Commute x.1 y.1 ∧ Commute x.2 y.2

full_name: MulHom.fst
code: /-- Given magmas `M`, `N`, the natural projection homomorphism from `M × N` to `M`. -/
@[to_additive
      "Given additive magmas `A`, `B`, the natural projection homomorphism
      from `A × B` to `A`"]
def fst : M × N →ₙ* M 
goal: M × N →ₙ* M

full_name: AddHom.fst
code: /-- Given magmas `M`, `N`, the natural projection homomorphism from `M × N` to `M`. -/
@[to_additive
      "Given additive magmas `A`, `B`, the natural projection homomorphism
      from `A × B` to `A`"]
def fst : M × N →ₙ* M 
goal: AddHom (M × N) M

full_name: MulHom.snd
code: /-- Given magmas `M`, `N`, the natural projection homomorphism from `M × N` to `N`. -/
@[to_additive
      "Given additive magmas `A`, `B`, the natural projection homomorphism
      from `A × B` to `B`"]
def snd : M × N →ₙ* N 
goal: M × N →ₙ* N

full_name: AddHom.snd
code: /-- Given magmas `M`, `N`, the natural projection homomorphism from `M × N` to `N`. -/
@[to_additive
      "Given additive magmas `A`, `B`, the natural projection homomorphism
      from `A × B` to `B`"]
def snd : M × N →ₙ* N 
goal: AddHom (M × N) N

full_name: AddHom.coe_fst
code: @[to_additive (attr := simp)]
theorem coe_fst : ⇑(fst M N) = Prod.fst 
goal: ⇑(AddHom.fst M N) = Prod.fst

full_name: MulHom.coe_fst
code: @[to_additive (attr := simp)]
theorem coe_fst : ⇑(fst M N) = Prod.fst 
goal: ⇑(MulHom.fst M N) = Prod.fst

full_name: MulHom.coe_snd
code: @[to_additive (attr := simp)]
theorem coe_snd : ⇑(snd M N) = Prod.snd 
goal: ⇑(MulHom.snd M N) = Prod.snd

full_name: AddHom.coe_snd
code: @[to_additive (attr := simp)]
theorem coe_snd : ⇑(snd M N) = Prod.snd 
goal: ⇑(AddHom.snd M N) = Prod.snd

full_name: AddHom.prod
code: /-- Combine two `MonoidHom`s `f : M →ₙ* N`, `g : M →ₙ* P` into
`f.prod g : M →ₙ* (N × P)` given by `(f.prod g) x = (f x, g x)`. -/
@[to_additive prod
      "Combine two `AddMonoidHom`s `f : AddHom M N`, `g : AddHom M P` into
      `f.prod g : AddHom M (N × P)` given by `(f.prod g) x = (f x, g x)`"]
protected def prod (f : M →ₙ* N) (g : M →ₙ* P) :
    M →ₙ* N × P 
goal: AddHom M (N × P)

full_name: MulHom.prod
code: /-- Combine two `MonoidHom`s `f : M →ₙ* N`, `g : M →ₙ* P` into
`f.prod g : M →ₙ* (N × P)` given by `(f.prod g) x = (f x, g x)`. -/
@[to_additive prod
      "Combine two `AddMonoidHom`s `f : AddHom M N`, `g : AddHom M P` into
      `f.prod g : AddHom M (N × P)` given by `(f.prod g) x = (f x, g x)`"]
protected def prod (f : M →ₙ* N) (g : M →ₙ* P) :
    M →ₙ* N × P 
goal: M →ₙ* N × P

full_name: AddHom.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (f : M →ₙ* N) (g : M →ₙ* P) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: MulHom.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (f : M →ₙ* N) (g : M →ₙ* P) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: AddHom.prod_apply
code: @[to_additive (attr := simp) prod_apply]
theorem prod_apply (f : M →ₙ* N) (g : M →ₙ* P) (x) : f.prod g x = (f x, g x) 
goal: (f.prod g) x = (f x, g x)

full_name: MulHom.prod_apply
code: @[to_additive (attr := simp) prod_apply]
theorem prod_apply (f : M →ₙ* N) (g : M →ₙ* P) (x) : f.prod g x = (f x, g x) 
goal: (f.prod g) x = (f x, g x)

full_name: AddHom.fst_comp_prod
code: @[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (fst N P).comp (f.prod g) = f 
goal: (AddHom.fst N P).comp (f.prod g) = f

full_name: MulHom.fst_comp_prod
code: @[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (fst N P).comp (f.prod g) = f 
goal: (MulHom.fst N P).comp (f.prod g) = f

full_name: AddHom.snd_comp_prod
code: @[to_additive (attr := simp) snd_comp_prod]
theorem snd_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (snd N P).comp (f.prod g) = g 
goal: (AddHom.snd N P).comp (f.prod g) = g

full_name: MulHom.snd_comp_prod
code: @[to_additive (attr := simp) snd_comp_prod]
theorem snd_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (snd N P).comp (f.prod g) = g 
goal: (MulHom.snd N P).comp (f.prod g) = g

full_name: MulHom.prod_unique
code: @[to_additive (attr := simp) prod_unique]
theorem prod_unique (f : M →ₙ* N × P) : ((fst N P).comp f).prod ((snd N P).comp f) = f 
goal: ((MulHom.fst N P).comp f).prod ((MulHom.snd N P).comp f) = f

full_name: AddHom.prod_unique
code: @[to_additive (attr := simp) prod_unique]
theorem prod_unique (f : M →ₙ* N × P) : ((fst N P).comp f).prod ((snd N P).comp f) = f 
goal: ((AddHom.fst N P).comp f).prod ((AddHom.snd N P).comp f) = f

full_name: AddHom.prodMap
code: /-- `Prod.map` as a `MonoidHom`. -/
@[to_additive prodMap "`Prod.map` as an `AddMonoidHom`"]
def prodMap : M × N →ₙ* M' × N' 
goal: AddHom (M × N) (M' × N')

full_name: MulHom.prodMap
code: /-- `Prod.map` as a `MonoidHom`. -/
@[to_additive prodMap "`Prod.map` as an `AddMonoidHom`"]
def prodMap : M × N →ₙ* M' × N' 
goal: M × N →ₙ* M' × N'

full_name: MulHom.prodMap_def
code: @[to_additive prodMap_def]
theorem prodMap_def : prodMap f g = (f.comp (fst M N)).prod (g.comp (snd M N)) 
goal: f.prodMap g = (f.comp (MulHom.fst M N)).prod (g.comp (MulHom.snd M N))

full_name: AddHom.prodMap_def
code: @[to_additive prodMap_def]
theorem prodMap_def : prodMap f g = (f.comp (fst M N)).prod (g.comp (snd M N)) 
goal: f.prodMap g = (f.comp (AddHom.fst M N)).prod (g.comp (AddHom.snd M N))

full_name: AddHom.coe_prodMap
code: @[to_additive (attr := simp) coe_prodMap]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g 
goal: ⇑(f.prodMap g) = Prod.map ⇑f ⇑g

full_name: MulHom.coe_prodMap
code: @[to_additive (attr := simp) coe_prodMap]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g 
goal: ⇑(f.prodMap g) = Prod.map ⇑f ⇑g

full_name: AddHom.prod_comp_prodMap
code: @[to_additive prod_comp_prodMap]
theorem prod_comp_prodMap (f : P →ₙ* M) (g : P →ₙ* N) (f' : M →ₙ* M') (g' : N →ₙ* N') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) 
goal: (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)

full_name: MulHom.prod_comp_prodMap
code: @[to_additive prod_comp_prodMap]
theorem prod_comp_prodMap (f : P →ₙ* M) (g : P →ₙ* N) (f' : M →ₙ* M') (g' : N →ₙ* N') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) 
goal: (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)

full_name: MulHom.coprod
code: /-- Coproduct of two `MulHom`s with the same codomain:
  `f.coprod g (p : M × N) = f p.1 * g p.2`.
  (Commutative codomain; for the general case, see `MulHom.noncommCoprod`) -/
@[to_additive
    "Coproduct of two `AddHom`s with the same codomain:
    `f.coprod g (p : M × N) = f p.1 + g p.2`.
    (Commutative codomain; for the general case, see `AddHom.noncommCoprod`)"]
def coprod : M × N →ₙ* P 
goal: M × N →ₙ* P

full_name: AddHom.coprod
code: /-- Coproduct of two `MulHom`s with the same codomain:
  `f.coprod g (p : M × N) = f p.1 * g p.2`.
  (Commutative codomain; for the general case, see `MulHom.noncommCoprod`) -/
@[to_additive
    "Coproduct of two `AddHom`s with the same codomain:
    `f.coprod g (p : M × N) = f p.1 + g p.2`.
    (Commutative codomain; for the general case, see `AddHom.noncommCoprod`)"]
def coprod : M × N →ₙ* P 
goal: AddHom (M × N) P

full_name: AddHom.coprod_apply
code: @[to_additive (attr := simp)]
theorem coprod_apply (p : M × N) : f.coprod g p = f p.1 * g p.2 
goal: (f.coprod g) p = f p.1 + g p.2

full_name: MulHom.coprod_apply
code: @[to_additive (attr := simp)]
theorem coprod_apply (p : M × N) : f.coprod g p = f p.1 * g p.2 
goal: (f.coprod g) p = f p.1 * g p.2

full_name: MulHom.comp_coprod
code: @[to_additive]
theorem comp_coprod {Q : Type*} [CommSemigroup Q] (h : P →ₙ* Q) (f : M →ₙ* P) (g : N →ₙ* P) :
    h.comp (f.coprod g) = (h.comp f).coprod (h.comp g) 
goal: h.comp (f.coprod g) = (h.comp f).coprod (h.comp g)

full_name: AddHom.comp_coprod
code: @[to_additive]
theorem comp_coprod {Q : Type*} [CommSemigroup Q] (h : P →ₙ* Q) (f : M →ₙ* P) (g : N →ₙ* P) :
    h.comp (f.coprod g) = (h.comp f).coprod (h.comp g) 
goal: h.comp (f.coprod g) = (h.comp f).coprod (h.comp g)

full_name: AddMonoidHom.fst
code: /-- Given monoids `M`, `N`, the natural projection homomorphism from `M × N` to `M`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural projection homomorphism
      from `A × B` to `A`"]
def fst : M × N →* M 
goal: M × N →+ M

full_name: MonoidHom.fst
code: /-- Given monoids `M`, `N`, the natural projection homomorphism from `M × N` to `M`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural projection homomorphism
      from `A × B` to `A`"]
def fst : M × N →* M 
goal: M × N →* M

full_name: AddMonoidHom.snd
code: /-- Given monoids `M`, `N`, the natural projection homomorphism from `M × N` to `N`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural projection homomorphism
      from `A × B` to `B`"]
def snd : M × N →* N 
goal: M × N →+ N

full_name: MonoidHom.snd
code: /-- Given monoids `M`, `N`, the natural projection homomorphism from `M × N` to `N`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural projection homomorphism
      from `A × B` to `B`"]
def snd : M × N →* N 
goal: M × N →* N

full_name: MonoidHom.inl
code: /-- Given monoids `M`, `N`, the natural inclusion homomorphism from `M` to `M × N`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural inclusion homomorphism
      from `A` to `A × B`."]
def inl : M →* M × N 
goal: M →* M × N

full_name: AddMonoidHom.inl
code: /-- Given monoids `M`, `N`, the natural inclusion homomorphism from `M` to `M × N`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural inclusion homomorphism
      from `A` to `A × B`."]
def inl : M →* M × N 
goal: M →+ M × N

full_name: MonoidHom.inr
code: /-- Given monoids `M`, `N`, the natural inclusion homomorphism from `N` to `M × N`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural inclusion homomorphism
      from `B` to `A × B`."]
def inr : N →* M × N 
goal: N →* M × N

full_name: AddMonoidHom.inr
code: /-- Given monoids `M`, `N`, the natural inclusion homomorphism from `N` to `M × N`. -/
@[to_additive
      "Given additive monoids `A`, `B`, the natural inclusion homomorphism
      from `B` to `A × B`."]
def inr : N →* M × N 
goal: N →+ M × N

full_name: MonoidHom.coe_fst
code: @[to_additive (attr := simp)]
theorem coe_fst : ⇑(fst M N) = Prod.fst 
goal: ⇑(MonoidHom.fst M N) = Prod.fst

full_name: AddMonoidHom.coe_fst
code: @[to_additive (attr := simp)]
theorem coe_fst : ⇑(fst M N) = Prod.fst 
goal: ⇑(AddMonoidHom.fst M N) = Prod.fst

full_name: AddMonoidHom.coe_snd
code: @[to_additive (attr := simp)]
theorem coe_snd : ⇑(snd M N) = Prod.snd 
goal: ⇑(AddMonoidHom.snd M N) = Prod.snd

full_name: MonoidHom.coe_snd
code: @[to_additive (attr := simp)]
theorem coe_snd : ⇑(snd M N) = Prod.snd 
goal: ⇑(MonoidHom.snd M N) = Prod.snd

full_name: MonoidHom.inl_apply
code: @[to_additive (attr := simp)]
theorem inl_apply (x) : inl M N x = (x, 1) 
goal: (MonoidHom.inl M N) x = (x, 1)

full_name: AddMonoidHom.inl_apply
code: @[to_additive (attr := simp)]
theorem inl_apply (x) : inl M N x = (x, 1) 
goal: (AddMonoidHom.inl M N) x = (x, 0)

full_name: MonoidHom.inr_apply
code: @[to_additive (attr := simp)]
theorem inr_apply (y) : inr M N y = (1, y) 
goal: (MonoidHom.inr M N) y = (1, y)

full_name: AddMonoidHom.inr_apply
code: @[to_additive (attr := simp)]
theorem inr_apply (y) : inr M N y = (1, y) 
goal: (AddMonoidHom.inr M N) y = (0, y)

full_name: AddMonoidHom.fst_comp_inl
code: @[to_additive (attr := simp)]
theorem fst_comp_inl : (fst M N).comp (inl M N) = id M 
goal: (AddMonoidHom.fst M N).comp (AddMonoidHom.inl M N) = AddMonoidHom.id M

full_name: MonoidHom.fst_comp_inl
code: @[to_additive (attr := simp)]
theorem fst_comp_inl : (fst M N).comp (inl M N) = id M 
goal: (MonoidHom.fst M N).comp (MonoidHom.inl M N) = MonoidHom.id M

full_name: AddMonoidHom.snd_comp_inl
code: @[to_additive (attr := simp)]
theorem snd_comp_inl : (snd M N).comp (inl M N) = 1 
goal: (AddMonoidHom.snd M N).comp (AddMonoidHom.inl M N) = 0

full_name: MonoidHom.snd_comp_inl
code: @[to_additive (attr := simp)]
theorem snd_comp_inl : (snd M N).comp (inl M N) = 1 
goal: (MonoidHom.snd M N).comp (MonoidHom.inl M N) = 1

full_name: AddMonoidHom.fst_comp_inr
code: @[to_additive (attr := simp)]
theorem fst_comp_inr : (fst M N).comp (inr M N) = 1 
goal: (AddMonoidHom.fst M N).comp (AddMonoidHom.inr M N) = 0

full_name: MonoidHom.fst_comp_inr
code: @[to_additive (attr := simp)]
theorem fst_comp_inr : (fst M N).comp (inr M N) = 1 
goal: (MonoidHom.fst M N).comp (MonoidHom.inr M N) = 1

full_name: MonoidHom.snd_comp_inr
code: @[to_additive (attr := simp)]
theorem snd_comp_inr : (snd M N).comp (inr M N) = id N 
goal: (MonoidHom.snd M N).comp (MonoidHom.inr M N) = MonoidHom.id N

full_name: AddMonoidHom.snd_comp_inr
code: @[to_additive (attr := simp)]
theorem snd_comp_inr : (snd M N).comp (inr M N) = id N 
goal: (AddMonoidHom.snd M N).comp (AddMonoidHom.inr M N) = AddMonoidHom.id N

full_name: AddMonoidHom.addCommute_inl_inr
code: @[to_additive]
theorem commute_inl_inr (m : M) (n : N) : Commute (inl M N m) (inr M N n) 
goal: AddCommute ((AddMonoidHom.inl M N) m) ((AddMonoidHom.inr M N) n)

full_name: MonoidHom.commute_inl_inr
code: @[to_additive]
theorem commute_inl_inr (m : M) (n : N) : Commute (inl M N m) (inr M N n) 
goal: Commute ((MonoidHom.inl M N) m) ((MonoidHom.inr M N) n)

full_name: MonoidHom.prod
code: /-- Combine two `MonoidHom`s `f : M →* N`, `g : M →* P` into `f.prod g : M →* N × P`
given by `(f.prod g) x = (f x, g x)`. -/
@[to_additive prod
      "Combine two `AddMonoidHom`s `f : M →+ N`, `g : M →+ P` into
      `f.prod g : M →+ N × P` given by `(f.prod g) x = (f x, g x)`"]
protected def prod (f : M →* N) (g : M →* P) :
    M →* N × P 
goal: M →* N × P

full_name: AddMonoidHom.prod
code: /-- Combine two `MonoidHom`s `f : M →* N`, `g : M →* P` into `f.prod g : M →* N × P`
given by `(f.prod g) x = (f x, g x)`. -/
@[to_additive prod
      "Combine two `AddMonoidHom`s `f : M →+ N`, `g : M →+ P` into
      `f.prod g : M →+ N × P` given by `(f.prod g) x = (f x, g x)`"]
protected def prod (f : M →* N) (g : M →* P) :
    M →* N × P 
goal: M →+ N × P

full_name: AddMonoidHom.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (f : M →* N) (g : M →* P) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: MonoidHom.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (f : M →* N) (g : M →* P) : ⇑(f.prod g) = Pi.prod f g 
goal: ⇑(f.prod g) = Pi.prod ⇑f ⇑g

full_name: AddMonoidHom.prod_apply
code: @[to_additive (attr := simp) prod_apply]
theorem prod_apply (f : M →* N) (g : M →* P) (x) : f.prod g x = (f x, g x) 
goal: (f.prod g) x = (f x, g x)

full_name: MonoidHom.prod_apply
code: @[to_additive (attr := simp) prod_apply]
theorem prod_apply (f : M →* N) (g : M →* P) (x) : f.prod g x = (f x, g x) 
goal: (f.prod g) x = (f x, g x)

full_name: AddMonoidHom.fst_comp_prod
code: @[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →* N) (g : M →* P) : (fst N P).comp (f.prod g) = f 
goal: (AddMonoidHom.fst N P).comp (f.prod g) = f

full_name: MonoidHom.fst_comp_prod
code: @[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →* N) (g : M →* P) : (fst N P).comp (f.prod g) = f 
goal: (MonoidHom.fst N P).comp (f.prod g) = f

full_name: AddMonoidHom.snd_comp_prod
code: @[to_additive (attr := simp) snd_comp_prod]
theorem snd_comp_prod (f : M →* N) (g : M →* P) : (snd N P).comp (f.prod g) = g 
goal: (AddMonoidHom.snd N P).comp (f.prod g) = g

full_name: MonoidHom.snd_comp_prod
code: @[to_additive (attr := simp) snd_comp_prod]
theorem snd_comp_prod (f : M →* N) (g : M →* P) : (snd N P).comp (f.prod g) = g 
goal: (MonoidHom.snd N P).comp (f.prod g) = g

full_name: MonoidHom.prod_unique
code: @[to_additive (attr := simp) prod_unique]
theorem prod_unique (f : M →* N × P) : ((fst N P).comp f).prod ((snd N P).comp f) = f 
goal: ((MonoidHom.fst N P).comp f).prod ((MonoidHom.snd N P).comp f) = f

full_name: AddMonoidHom.prod_unique
code: @[to_additive (attr := simp) prod_unique]
theorem prod_unique (f : M →* N × P) : ((fst N P).comp f).prod ((snd N P).comp f) = f 
goal: ((AddMonoidHom.fst N P).comp f).prod ((AddMonoidHom.snd N P).comp f) = f

full_name: MonoidHom.prodMap
code: /-- `prod.map` as a `MonoidHom`. -/
@[to_additive prodMap "`prod.map` as an `AddMonoidHom`."]
def prodMap : M × N →* M' × N' 
goal: M × N →* M' × N'

full_name: AddMonoidHom.prodMap
code: /-- `prod.map` as a `MonoidHom`. -/
@[to_additive prodMap "`prod.map` as an `AddMonoidHom`."]
def prodMap : M × N →* M' × N' 
goal: M × N →+ M' × N'

full_name: MonoidHom.prodMap_def
code: @[to_additive prodMap_def]
theorem prodMap_def : prodMap f g = (f.comp (fst M N)).prod (g.comp (snd M N)) 
goal: f.prodMap g = (f.comp (MonoidHom.fst M N)).prod (g.comp (MonoidHom.snd M N))

full_name: AddMonoidHom.prodMap_def
code: @[to_additive prodMap_def]
theorem prodMap_def : prodMap f g = (f.comp (fst M N)).prod (g.comp (snd M N)) 
goal: f.prodMap g = (f.comp (AddMonoidHom.fst M N)).prod (g.comp (AddMonoidHom.snd M N))

full_name: MonoidHom.coe_prodMap
code: @[to_additive (attr := simp) coe_prodMap]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g 
goal: ⇑(f.prodMap g) = Prod.map ⇑f ⇑g

full_name: AddMonoidHom.coe_prodMap
code: @[to_additive (attr := simp) coe_prodMap]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g 
goal: ⇑(f.prodMap g) = Prod.map ⇑f ⇑g

full_name: AddMonoidHom.prod_comp_prodMap
code: @[to_additive prod_comp_prodMap]
theorem prod_comp_prodMap (f : P →* M) (g : P →* N) (f' : M →* M') (g' : N →* N') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) 
goal: (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)

full_name: MonoidHom.prod_comp_prodMap
code: @[to_additive prod_comp_prodMap]
theorem prod_comp_prodMap (f : P →* M) (g : P →* N) (f' : M →* M') (g' : N →* N') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) 
goal: (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)

full_name: MonoidHom.coprod
code: /-- Coproduct of two `MonoidHom`s with the same codomain:
  `f.coprod g (p : M × N) = f p.1 * g p.2`.
  (Commutative case; for the general case, see `MonoidHom.noncommCoprod`.)-/
@[to_additive
    "Coproduct of two `AddMonoidHom`s with the same codomain:
    `f.coprod g (p : M × N) = f p.1 + g p.2`.
    (Commutative case; for the general case, see `AddHom.noncommCoprod`.)"]
def coprod : M × N →* P 
goal: M × N →* P

full_name: AddMonoidHom.coprod
code: /-- Coproduct of two `MonoidHom`s with the same codomain:
  `f.coprod g (p : M × N) = f p.1 * g p.2`.
  (Commutative case; for the general case, see `MonoidHom.noncommCoprod`.)-/
@[to_additive
    "Coproduct of two `AddMonoidHom`s with the same codomain:
    `f.coprod g (p : M × N) = f p.1 + g p.2`.
    (Commutative case; for the general case, see `AddHom.noncommCoprod`.)"]
def coprod : M × N →* P 
goal: M × N →+ P

full_name: AddMonoidHom.coprod_apply
code: @[to_additive (attr := simp)]
theorem coprod_apply (p : M × N) : f.coprod g p = f p.1 * g p.2 
goal: (f.coprod g) p = f p.1 + g p.2

full_name: MonoidHom.coprod_apply
code: @[to_additive (attr := simp)]
theorem coprod_apply (p : M × N) : f.coprod g p = f p.1 * g p.2 
goal: (f.coprod g) p = f p.1 * g p.2

full_name: MonoidHom.coprod_comp_inl
code: @[to_additive (attr := simp)]
theorem coprod_comp_inl : (f.coprod g).comp (inl M N) = f 
goal: (f.coprod g).comp (MonoidHom.inl M N) = f

full_name: AddMonoidHom.coprod_comp_inl
code: @[to_additive (attr := simp)]
theorem coprod_comp_inl : (f.coprod g).comp (inl M N) = f 
goal: (f.coprod g).comp (AddMonoidHom.inl M N) = f

full_name: AddMonoidHom.coprod_comp_inr
code: @[to_additive (attr := simp)]
theorem coprod_comp_inr : (f.coprod g).comp (inr M N) = g 
goal: (f.coprod g).comp (AddMonoidHom.inr M N) = g

full_name: MonoidHom.coprod_comp_inr
code: @[to_additive (attr := simp)]
theorem coprod_comp_inr : (f.coprod g).comp (inr M N) = g 
goal: (f.coprod g).comp (MonoidHom.inr M N) = g

full_name: MonoidHom.coprod_unique
code: @[to_additive (attr := simp)]
theorem coprod_unique (f : M × N →* P) : (f.comp (inl M N)).coprod (f.comp (inr M N)) = f 
goal: (f.comp (MonoidHom.inl M N)).coprod (f.comp (MonoidHom.inr M N)) = f

full_name: AddMonoidHom.coprod_unique
code: @[to_additive (attr := simp)]
theorem coprod_unique (f : M × N →* P) : (f.comp (inl M N)).coprod (f.comp (inr M N)) = f 
goal: (f.comp (AddMonoidHom.inl M N)).coprod (f.comp (AddMonoidHom.inr M N)) = f

full_name: AddMonoidHom.coprod_inl_inr
code: @[to_additive (attr := simp)]
theorem coprod_inl_inr {M N : Type*} [CommMonoid M] [CommMonoid N] :
    (inl M N).coprod (inr M N) = id (M × N) 
goal: (AddMonoidHom.inl M N).coprod (AddMonoidHom.inr M N) = AddMonoidHom.id (M × N)

full_name: MonoidHom.coprod_inl_inr
code: @[to_additive (attr := simp)]
theorem coprod_inl_inr {M N : Type*} [CommMonoid M] [CommMonoid N] :
    (inl M N).coprod (inr M N) = id (M × N) 
goal: (MonoidHom.inl M N).coprod (MonoidHom.inr M N) = MonoidHom.id (M × N)

full_name: AddMonoidHom.comp_coprod
code: @[to_additive]
theorem comp_coprod {Q : Type*} [CommMonoid Q] (h : P →* Q) (f : M →* P) (g : N →* P) :
    h.comp (f.coprod g) = (h.comp f).coprod (h.comp g) 
goal: h.comp (f.coprod g) = (h.comp f).coprod (h.comp g)

full_name: MonoidHom.comp_coprod
code: @[to_additive]
theorem comp_coprod {Q : Type*} [CommMonoid Q] (h : P →* Q) (f : M →* P) (g : N →* P) :
    h.comp (f.coprod g) = (h.comp f).coprod (h.comp g) 
goal: h.comp (f.coprod g) = (h.comp f).coprod (h.comp g)

full_name: MulEquiv.prodComm
code: /-- The equivalence between `M × N` and `N × M` given by swapping the components
is multiplicative. -/
@[to_additive prodComm
      "The equivalence between `M × N` and `N × M` given by swapping the
      components is additive."]
def prodComm : M × N ≃* N × M 
goal: M × N ≃* N × M

full_name: AddEquiv.prodComm
code: /-- The equivalence between `M × N` and `N × M` given by swapping the components
is multiplicative. -/
@[to_additive prodComm
      "The equivalence between `M × N` and `N × M` given by swapping the
      components is additive."]
def prodComm : M × N ≃* N × M 
goal: M × N ≃+ N × M

full_name: AddEquiv.coe_prodComm
code: @[to_additive (attr := simp) coe_prodComm]
theorem coe_prodComm : ⇑(prodComm : M × N ≃* N × M) = Prod.swap 
goal: ⇑AddEquiv.prodComm = Prod.swap

full_name: MulEquiv.coe_prodComm
code: @[to_additive (attr := simp) coe_prodComm]
theorem coe_prodComm : ⇑(prodComm : M × N ≃* N × M) = Prod.swap 
goal: ⇑MulEquiv.prodComm = Prod.swap

full_name: MulEquiv.coe_prodComm_symm
code: @[to_additive (attr := simp) coe_prodComm_symm]
theorem coe_prodComm_symm : ⇑(prodComm : M × N ≃* N × M).symm = Prod.swap 
goal: ⇑MulEquiv.prodComm.symm = Prod.swap

full_name: AddEquiv.coe_prodComm_symm
code: @[to_additive (attr := simp) coe_prodComm_symm]
theorem coe_prodComm_symm : ⇑(prodComm : M × N ≃* N × M).symm = Prod.swap 
goal: ⇑AddEquiv.prodComm.symm = Prod.swap

full_name: MulEquiv.prodProdProdComm_apply
code: /-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[to_additive (attr := simps apply) prodProdProdComm
    "Four-way commutativity of `Prod`.\nThe name matches `mul_mul_mul_comm`"]
def prodProdProdComm : (M × N) × M' × N' ≃* (M × M') × N × N' 
goal: (MulEquiv.prodProdProdComm M N M' N') mnmn = ((mnmn.1.1, mnmn.2.1), mnmn.1.2, mnmn.2.2)

full_name: AddEquiv.prodProdProdComm_apply
code: /-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[to_additive (attr := simps apply) prodProdProdComm
    "Four-way commutativity of `Prod`.\nThe name matches `mul_mul_mul_comm`"]
def prodProdProdComm : (M × N) × M' × N' ≃* (M × M') × N × N' 
goal: (AddEquiv.prodProdProdComm M N M' N') mnmn = ((mnmn.1.1, mnmn.2.1), mnmn.1.2, mnmn.2.2)

full_name: AddEquiv.prodProdProdComm
code: /-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[to_additive (attr := simps apply) prodProdProdComm
    "Four-way commutativity of `Prod`.\nThe name matches `mul_mul_mul_comm`"]
def prodProdProdComm : (M × N) × M' × N' ≃* (M × M') × N × N' 
goal: (M × N) × M' × N' ≃+ (M × M') × N × N'

full_name: MulEquiv.prodProdProdComm
code: /-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[to_additive (attr := simps apply) prodProdProdComm
    "Four-way commutativity of `Prod`.\nThe name matches `mul_mul_mul_comm`"]
def prodProdProdComm : (M × N) × M' × N' ≃* (M × M') × N × N' 
goal: (M × N) × M' × N' ≃* (M × M') × N × N'

full_name: MulEquiv.prodProdProdComm_toEquiv
code: @[to_additive (attr := simp) prodProdProdComm_toEquiv]
theorem prodProdProdComm_toEquiv :
    (prodProdProdComm M N M' N' : _ ≃ _) = Equiv.prodProdProdComm M N M' N' 
goal: ↑(MulEquiv.prodProdProdComm M N M' N') = Equiv.prodProdProdComm M N M' N'

full_name: AddEquiv.prodProdProdComm_toEquiv
code: @[to_additive (attr := simp) prodProdProdComm_toEquiv]
theorem prodProdProdComm_toEquiv :
    (prodProdProdComm M N M' N' : _ ≃ _) = Equiv.prodProdProdComm M N M' N' 
goal: ↑(AddEquiv.prodProdProdComm M N M' N') = Equiv.prodProdProdComm M N M' N'

full_name: MulEquiv.prodProdProdComm_symm
code: @[simp]
theorem prodProdProdComm_symm : (prodProdProdComm M N M' N').symm = prodProdProdComm M M' N N' 
goal: (MulEquiv.prodProdProdComm M N M' N').symm = MulEquiv.prodProdProdComm M M' N N'

full_name: MulEquiv.prodCongr
code: /-- Product of multiplicative isomorphisms; the maps come from `Equiv.prodCongr`. -/
@[to_additive prodCongr "Product of additive isomorphisms; the maps come from `Equiv.prodCongr`."]
def prodCongr (f : M ≃* M') (g : N ≃* N') : M × N ≃* M' × N' 
goal: M × N ≃* M' × N'

full_name: AddEquiv.prodCongr
code: /-- Product of multiplicative isomorphisms; the maps come from `Equiv.prodCongr`. -/
@[to_additive prodCongr "Product of additive isomorphisms; the maps come from `Equiv.prodCongr`."]
def prodCongr (f : M ≃* M') (g : N ≃* N') : M × N ≃* M' × N' 
goal: M × N ≃+ M' × N'

full_name: MulEquiv.uniqueProd
code: /-- Multiplying by the trivial monoid doesn't change the structure. -/
@[to_additive uniqueProd "Multiplying by the trivial monoid doesn't change the structure."]
def uniqueProd [Unique N] : N × M ≃* M 
goal: N × M ≃* M

full_name: AddEquiv.uniqueProd
code: /-- Multiplying by the trivial monoid doesn't change the structure. -/
@[to_additive uniqueProd "Multiplying by the trivial monoid doesn't change the structure."]
def uniqueProd [Unique N] : N × M ≃* M 
goal: N × M ≃+ M

full_name: AddEquiv.prodUnique
code: /-- Multiplying by the trivial monoid doesn't change the structure. -/
@[to_additive prodUnique "Multiplying by the trivial monoid doesn't change the structure."]
def prodUnique [Unique N] : M × N ≃* M 
goal: M × N ≃+ M

full_name: MulEquiv.prodUnique
code: /-- Multiplying by the trivial monoid doesn't change the structure. -/
@[to_additive prodUnique "Multiplying by the trivial monoid doesn't change the structure."]
def prodUnique [Unique N] : M × N ≃* M 
goal: M × N ≃* M

full_name: MulEquiv.prodUnits
code: /-- The monoid equivalence between units of a product of two monoids, and the product of the
    units of each monoid. -/
@[to_additive prodAddUnits
      "The additive monoid equivalence between additive units of a product
      of two additive monoids, and the product of the additive units of each additive monoid."]
def prodUnits : (M × N)ˣ ≃* Mˣ × Nˣ 
goal: (M × N)ˣ ≃* Mˣ × Nˣ

full_name: AddEquiv.prodAddUnits
code: /-- The monoid equivalence between units of a product of two monoids, and the product of the
    units of each monoid. -/
@[to_additive prodAddUnits
      "The additive monoid equivalence between additive units of a product
      of two additive monoids, and the product of the additive units of each additive monoid."]
def prodUnits : (M × N)ˣ ≃* Mˣ × Nˣ 
goal: AddUnits (M × N) ≃+ AddUnits M × AddUnits N

full_name: Units.embedProduct
code: /-- Canonical homomorphism of monoids from `αˣ` into `α × αᵐᵒᵖ`.
Used mainly to define the natural topology of `αˣ`. -/
@[to_additive (attr := simps)
      "Canonical homomorphism of additive monoids from `AddUnits α` into `α × αᵃᵒᵖ`.
      Used mainly to define the natural topology of `AddUnits α`."]
def embedProduct (α : Type*) [Monoid α] : αˣ →* α × αᵐᵒᵖ 
goal: αˣ →* α × αᵐᵒᵖ

full_name: Units.embedProduct_apply
code: /-- Canonical homomorphism of monoids from `αˣ` into `α × αᵐᵒᵖ`.
Used mainly to define the natural topology of `αˣ`. -/
@[to_additive (attr := simps)
      "Canonical homomorphism of additive monoids from `AddUnits α` into `α × αᵃᵒᵖ`.
      Used mainly to define the natural topology of `AddUnits α`."]
def embedProduct (α : Type*) [Monoid α] : αˣ →* α × αᵐᵒᵖ 
goal: (Units.embedProduct α) x = (↑x, MulOpposite.op ↑x⁻¹)

full_name: AddUnits.embedProduct
code: /-- Canonical homomorphism of monoids from `αˣ` into `α × αᵐᵒᵖ`.
Used mainly to define the natural topology of `αˣ`. -/
@[to_additive (attr := simps)
      "Canonical homomorphism of additive monoids from `AddUnits α` into `α × αᵃᵒᵖ`.
      Used mainly to define the natural topology of `AddUnits α`."]
def embedProduct (α : Type*) [Monoid α] : αˣ →* α × αᵐᵒᵖ 
goal: AddUnits α →+ α × αᵃᵒᵖ

full_name: AddUnits.embedProduct_apply
code: /-- Canonical homomorphism of monoids from `αˣ` into `α × αᵐᵒᵖ`.
Used mainly to define the natural topology of `αˣ`. -/
@[to_additive (attr := simps)
      "Canonical homomorphism of additive monoids from `AddUnits α` into `α × αᵃᵒᵖ`.
      Used mainly to define the natural topology of `AddUnits α`."]
def embedProduct (α : Type*) [Monoid α] : αˣ →* α × αᵐᵒᵖ 
goal: (AddUnits.embedProduct α) x = (↑x, AddOpposite.op ↑(-x))

full_name: AddUnits.embedProduct_injective
code: @[to_additive]
theorem embedProduct_injective (α : Type*) [Monoid α] : Function.Injective (embedProduct α) 
goal: Function.Injective ⇑(AddUnits.embedProduct α)

full_name: Units.embedProduct_injective
code: @[to_additive]
theorem embedProduct_injective (α : Type*) [Monoid α] : Function.Injective (embedProduct α) 
goal: Function.Injective ⇑(Units.embedProduct α)

full_name: addAddHom
code: /-- Multiplication as a multiplicative homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive homomorphism."]
def mulMulHom [CommSemigroup α] :
    α × α →ₙ* α 
goal: AddHom (α × α) α

full_name: mulMulHom_apply
code: /-- Multiplication as a multiplicative homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive homomorphism."]
def mulMulHom [CommSemigroup α] :
    α × α →ₙ* α 
goal: mulMulHom a = a.1 * a.2

full_name: mulMulHom
code: /-- Multiplication as a multiplicative homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive homomorphism."]
def mulMulHom [CommSemigroup α] :
    α × α →ₙ* α 
goal: α × α →ₙ* α

full_name: addAddHom_apply
code: /-- Multiplication as a multiplicative homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive homomorphism."]
def mulMulHom [CommSemigroup α] :
    α × α →ₙ* α 
goal: addAddHom a = a.1 + a.2

full_name: mulMonoidHom_apply
code: /-- Multiplication as a monoid homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive monoid homomorphism."]
def mulMonoidHom [CommMonoid α] : α × α →* α 
goal: ∀ (a : α × α), mulMonoidHom a = mulMulHom.toFun a

full_name: mulMonoidHom
code: /-- Multiplication as a monoid homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive monoid homomorphism."]
def mulMonoidHom [CommMonoid α] : α × α →* α 
goal: α × α →* α

full_name: addAddMonoidHom_apply
code: /-- Multiplication as a monoid homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive monoid homomorphism."]
def mulMonoidHom [CommMonoid α] : α × α →* α 
goal: ∀ (a : α × α), addAddMonoidHom a = addAddHom.toFun a

full_name: addAddMonoidHom
code: /-- Multiplication as a monoid homomorphism. -/
@[to_additive (attr := simps) "Addition as an additive monoid homomorphism."]
def mulMonoidHom [CommMonoid α] : α × α →* α 
goal: α × α →+ α

full_name: subAddMonoidHom_apply
code: /-- Division as a monoid homomorphism. -/
@[to_additive (attr := simps) "Subtraction as an additive monoid homomorphism."]
def divMonoidHom [DivisionCommMonoid α] : α × α →* α 
goal: subAddMonoidHom a = a.1 - a.2

full_name: subAddMonoidHom
code: /-- Division as a monoid homomorphism. -/
@[to_additive (attr := simps) "Subtraction as an additive monoid homomorphism."]
def divMonoidHom [DivisionCommMonoid α] : α × α →* α 
goal: α × α →+ α

full_name: divMonoidHom
code: /-- Division as a monoid homomorphism. -/
@[to_additive (attr := simps) "Subtraction as an additive monoid homomorphism."]
def divMonoidHom [DivisionCommMonoid α] : α × α →* α 
goal: α × α →* α

full_name: divMonoidHom_apply
code: /-- Division as a monoid homomorphism. -/
@[to_additive (attr := simps) "Subtraction as an additive monoid homomorphism."]
def divMonoidHom [DivisionCommMonoid α] : α × α →* α 
goal: divMonoidHom a = a.1 / a.2