File: Mathlib/Algebra/Group/Hom/Defs.lean

full_name: ZeroHom.map_zero'
code: /-- `ZeroHom M N` is the type of functions `M → N` that preserve zero.

When possible, instead of parametrizing results over `(f : ZeroHom M N)`,
you should parametrize over `(F : Type*) [ZeroHomClass F M N] (f : F)`.

When you extend this structure, make sure to also extend `ZeroHomClass`.
-/
structure ZeroHom (M : Type*) (N : Type*) [Zero M] [Zero N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves 0 -/
  protected map_zero' : toFun 0 = 0
goal: self.toFun 0 = 0

full_name: ZeroHom
code: /-- `ZeroHom M N` is the type of functions `M → N` that preserve zero.

When possible, instead of parametrizing results over `(f : ZeroHom M N)`,
you should parametrize over `(F : Type*) [ZeroHomClass F M N] (f : F)`.

When you extend this structure, make sure to also extend `ZeroHomClass`.
-/
structure ZeroHom (M : Type*) (N : Type*) [Zero M] [Zero N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves 0 -/
  protected map_zero' : toFun 0 = 0
goal: Type (max u_10 u_11)

full_name: ZeroHom.toFun
code: /-- `ZeroHom M N` is the type of functions `M → N` that preserve zero.

When possible, instead of parametrizing results over `(f : ZeroHom M N)`,
you should parametrize over `(F : Type*) [ZeroHomClass F M N] (f : F)`.

When you extend this structure, make sure to also extend `ZeroHomClass`.
-/
structure ZeroHom (M : Type*) (N : Type*) [Zero M] [Zero N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves 0 -/
  protected map_zero' : toFun 0 = 0
goal: M → N

full_name: ZeroHomClass.map_zero
code: /-- `ZeroHomClass F M N` states that `F` is a type of zero-preserving homomorphisms.

You should extend this typeclass when you extend `ZeroHom`.
-/
class ZeroHomClass (F : Type*) (M N : outParam Type*) [Zero M] [Zero N] [FunLike F M N] :
    Prop where
  /-- The proposition that the function preserves 0 -/
  map_zero : ∀ f : F, f 0 = 0
goal: f 0 = 0

full_name: ZeroHomClass
code: /-- `ZeroHomClass F M N` states that `F` is a type of zero-preserving homomorphisms.

You should extend this typeclass when you extend `ZeroHom`.
-/
class ZeroHomClass (F : Type*) (M N : outParam Type*) [Zero M] [Zero N] [FunLike F M N] :
    Prop where
  /-- The proposition that the function preserves 0 -/
  map_zero : ∀ f : F, f 0 = 0
goal: Prop

full_name: AddHom.map_add'
code: /-- `AddHom M N` is the type of functions `M → N` that preserve addition.

When possible, instead of parametrizing results over `(f : AddHom M N)`,
you should parametrize over `(F : Type*) [AddHomClass F M N] (f : F)`.

When you extend this structure, make sure to extend `AddHomClass`.
-/
structure AddHom (M : Type*) (N : Type*) [Add M] [Add N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves addition -/
  protected map_add' : ∀ x y, toFun (x + y) = toFun x + toFun y
goal: self.toFun (x + y) = self.toFun x + self.toFun y

full_name: AddHom.toFun
code: /-- `AddHom M N` is the type of functions `M → N` that preserve addition.

When possible, instead of parametrizing results over `(f : AddHom M N)`,
you should parametrize over `(F : Type*) [AddHomClass F M N] (f : F)`.

When you extend this structure, make sure to extend `AddHomClass`.
-/
structure AddHom (M : Type*) (N : Type*) [Add M] [Add N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves addition -/
  protected map_add' : ∀ x y, toFun (x + y) = toFun x + toFun y
goal: M → N

full_name: AddHom
code: /-- `AddHom M N` is the type of functions `M → N` that preserve addition.

When possible, instead of parametrizing results over `(f : AddHom M N)`,
you should parametrize over `(F : Type*) [AddHomClass F M N] (f : F)`.

When you extend this structure, make sure to extend `AddHomClass`.
-/
structure AddHom (M : Type*) (N : Type*) [Add M] [Add N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves addition -/
  protected map_add' : ∀ x y, toFun (x + y) = toFun x + toFun y
goal: Type (max u_10 u_11)

full_name: AddHomClass
code: /-- `AddHomClass F M N` states that `F` is a type of addition-preserving homomorphisms.
You should declare an instance of this typeclass when you extend `AddHom`.
-/
class AddHomClass (F : Type*) (M N : outParam Type*) [Add M] [Add N] [FunLike F M N] : Prop where
  /-- The proposition that the function preserves addition -/
  map_add : ∀ (f : F) (x y : M), f (x + y) = f x + f y
goal: Prop

full_name: AddHomClass.map_add
code: /-- `AddHomClass F M N` states that `F` is a type of addition-preserving homomorphisms.
You should declare an instance of this typeclass when you extend `AddHom`.
-/
class AddHomClass (F : Type*) (M N : outParam Type*) [Add M] [Add N] [FunLike F M N] : Prop where
  /-- The proposition that the function preserves addition -/
  map_add : ∀ (f : F) (x y : M), f (x + y) = f x + f y
goal: f (x + y) = f x + f y

full_name: AddMonoidHom
code: /-- `M →+ N` is the type of functions `M → N` that preserve the `AddZeroClass` structure.

`AddMonoidHom` is also used for group homomorphisms.

When possible, instead of parametrizing results over `(f : M →+ N)`,
you should parametrize over `(F : Type*) [AddMonoidHomClass F M N] (f : F)`.

When you extend this structure, make sure to extend `AddMonoidHomClass`.
-/
structure AddMonoidHom (M : Type*) (N : Type*) [AddZeroClass M] [AddZeroClass N] extends
  ZeroHom M N, AddHom M N
goal: Type (max u_10 u_11)

full_name: «_aux_Mathlib_Algebra_Group_Hom_Defs___macroRules_term_→+__1»
code: /-- `M →+ N` denotes the type of additive monoid homomorphisms from `M` to `N`. -/
infixr:25 " →+ " => AddMonoidHom
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Group_Hom_Defs___unexpand_AddMonoidHom_1
code: /-- `M →+ N` denotes the type of additive monoid homomorphisms from `M` to `N`. -/
infixr:25 " →+ " => AddMonoidHom
goal: Lean.PrettyPrinter.Unexpander

full_name: AddMonoidHomClass
code: /-- `AddMonoidHomClass F M N` states that `F` is a type of `AddZeroClass`-preserving
homomorphisms.

You should also extend this typeclass when you extend `AddMonoidHom`.
-/
class AddMonoidHomClass (F M N : Type*) [AddZeroClass M] [AddZeroClass N] [FunLike F M N]
  extends AddHomClass F M N, ZeroHomClass F M N : Prop
goal: Prop

full_name: OneHom.map_one'
code: /-- `OneHom M N` is the type of functions `M → N` that preserve one.

When possible, instead of parametrizing results over `(f : OneHom M N)`,
you should parametrize over `(F : Type*) [OneHomClass F M N] (f : F)`.

When you extend this structure, make sure to also extend `OneHomClass`.
-/
@[to_additive]
structure OneHom (M : Type*) (N : Type*) [One M] [One N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves 1 -/
  protected map_one' : toFun 1 = 1
goal: self.toFun 1 = 1

full_name: OneHom.toFun
code: /-- `OneHom M N` is the type of functions `M → N` that preserve one.

When possible, instead of parametrizing results over `(f : OneHom M N)`,
you should parametrize over `(F : Type*) [OneHomClass F M N] (f : F)`.

When you extend this structure, make sure to also extend `OneHomClass`.
-/
@[to_additive]
structure OneHom (M : Type*) (N : Type*) [One M] [One N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves 1 -/
  protected map_one' : toFun 1 = 1
goal: M → N

full_name: OneHom
code: /-- `OneHom M N` is the type of functions `M → N` that preserve one.

When possible, instead of parametrizing results over `(f : OneHom M N)`,
you should parametrize over `(F : Type*) [OneHomClass F M N] (f : F)`.

When you extend this structure, make sure to also extend `OneHomClass`.
-/
@[to_additive]
structure OneHom (M : Type*) (N : Type*) [One M] [One N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves 1 -/
  protected map_one' : toFun 1 = 1
goal: Type (max u_10 u_11)

full_name: OneHomClass.map_one
code: /-- `OneHomClass F M N` states that `F` is a type of one-preserving homomorphisms.
You should extend this typeclass when you extend `OneHom`.
-/
@[to_additive]
class OneHomClass (F : Type*) (M N : outParam Type*) [One M] [One N] [FunLike F M N] : Prop where
  /-- The proposition that the function preserves 1 -/
  map_one : ∀ f : F, f 1 = 1
goal: f 1 = 1

full_name: OneHomClass
code: /-- `OneHomClass F M N` states that `F` is a type of one-preserving homomorphisms.
You should extend this typeclass when you extend `OneHom`.
-/
@[to_additive]
class OneHomClass (F : Type*) (M N : outParam Type*) [One M] [One N] [FunLike F M N] : Prop where
  /-- The proposition that the function preserves 1 -/
  map_one : ∀ f : F, f 1 = 1
goal: Prop

full_name: ZeroHom.funLike
code: @[to_additive]
instance OneHom.funLike : FunLike (OneHom M N) M N 
goal: FunLike (ZeroHom M N) M N

full_name: OneHom.funLike
code: @[to_additive]
instance OneHom.funLike : FunLike (OneHom M N) M N 
goal: FunLike (OneHom M N) M N

full_name: ZeroHom.zeroHomClass
code: @[to_additive]
instance OneHom.oneHomClass : OneHomClass (OneHom M N) M N 
goal: ZeroHomClass (ZeroHom M N) M N

full_name: OneHom.oneHomClass
code: @[to_additive]
instance OneHom.oneHomClass : OneHomClass (OneHom M N) M N 
goal: OneHomClass (OneHom M N) M N

full_name: map_zero
code: @[to_additive (attr := simp)]
theorem map_one [OneHomClass F M N] (f : F) : f 1 = 1 
goal: f 0 = 0

full_name: map_one
code: @[to_additive (attr := simp)]
theorem map_one [OneHomClass F M N] (f : F) : f 1 = 1 
goal: f 1 = 1

full_name: map_comp_zero
code: @[to_additive] lemma map_comp_one [OneHomClass F M N] (f : F) : f ∘ (1 : ι → M) = 1 
goal: ⇑f ∘ 0 = 0

full_name: map_comp_one
code: @[to_additive] lemma map_comp_one [OneHomClass F M N] (f : F) : f ∘ (1 : ι → M) = 1 
goal: ⇑f ∘ 1 = 1

full_name: Subsingleton.of_zeroHomClass
code: /-- In principle this could be an instance, but in practice it causes performance issues. -/
@[to_additive]
theorem Subsingleton.of_oneHomClass [Subsingleton M] [OneHomClass F M N] :
    Subsingleton F 
goal: Subsingleton F

full_name: Subsingleton.of_oneHomClass
code: /-- In principle this could be an instance, but in practice it causes performance issues. -/
@[to_additive]
theorem Subsingleton.of_oneHomClass [Subsingleton M] [OneHomClass F M N] :
    Subsingleton F 
goal: Subsingleton F

full_name: instSubsingletonZeroHom
code: @[to_additive] instance [Subsingleton M] : Subsingleton (OneHom M N) 
goal: Subsingleton (ZeroHom M N)

full_name: instSubsingletonOneHom
code: @[to_additive] instance [Subsingleton M] : Subsingleton (OneHom M N) 
goal: Subsingleton (OneHom M N)

full_name: map_eq_zero_iff
code: @[to_additive]
theorem map_eq_one_iff [OneHomClass F M N] (f : F) (hf : Function.Injective f)
    {x : M} :
    f x = 1 ↔ x = 1 
goal: f x = 0 ↔ x = 0

full_name: map_eq_one_iff
code: @[to_additive]
theorem map_eq_one_iff [OneHomClass F M N] (f : F) (hf : Function.Injective f)
    {x : M} :
    f x = 1 ↔ x = 1 
goal: f x = 1 ↔ x = 1

full_name: map_ne_zero_iff
code: @[to_additive]
theorem map_ne_one_iff {R S F : Type*} [One R] [One S] [FunLike F R S] [OneHomClass F R S] (f : F)
    (hf : Function.Injective f) {x : R} : f x ≠ 1 ↔ x ≠ 1 
goal: f x ≠ 0 ↔ x ≠ 0

full_name: map_ne_one_iff
code: @[to_additive]
theorem map_ne_one_iff {R S F : Type*} [One R] [One S] [FunLike F R S] [OneHomClass F R S] (f : F)
    (hf : Function.Injective f) {x : R} : f x ≠ 1 ↔ x ≠ 1 
goal: f x ≠ 1 ↔ x ≠ 1

full_name: ne_zero_of_map
code: @[to_additive]
theorem ne_one_of_map {R S F : Type*} [One R] [One S] [FunLike F R S] [OneHomClass F R S]
    {f : F} {x : R} (hx : f x ≠ 1) : x ≠ 1 
goal: x ≠ 0

full_name: ne_one_of_map
code: @[to_additive]
theorem ne_one_of_map {R S F : Type*} [One R] [One S] [FunLike F R S] [OneHomClass F R S]
    {f : F} {x : R} (hx : f x ≠ 1) : x ≠ 1 
goal: x ≠ 1

full_name: OneHomClass.toOneHom
code: /-- Turn an element of a type `F` satisfying `OneHomClass F M N` into an actual
`OneHom`. This is declared as the default coercion from `F` to `OneHom M N`. -/
@[to_additive (attr := coe)
"Turn an element of a type `F` satisfying `ZeroHomClass F M N` into an actual
`ZeroHom`. This is declared as the default coercion from `F` to `ZeroHom M N`."]
def OneHomClass.toOneHom [OneHomClass F M N] (f : F) : OneHom M N 
goal: OneHom M N

full_name: ZeroHomClass.toZeroHom
code: /-- Turn an element of a type `F` satisfying `OneHomClass F M N` into an actual
`OneHom`. This is declared as the default coercion from `F` to `OneHom M N`. -/
@[to_additive (attr := coe)
"Turn an element of a type `F` satisfying `ZeroHomClass F M N` into an actual
`ZeroHom`. This is declared as the default coercion from `F` to `ZeroHom M N`."]
def OneHomClass.toOneHom [OneHomClass F M N] (f : F) : OneHom M N 
goal: ZeroHom M N

full_name: instCoeTCOneHomOfOneHomClass
code: /-- Any type satisfying `OneHomClass` can be cast into `OneHom` via `OneHomClass.toOneHom`. -/
@[to_additive "Any type satisfying `ZeroHomClass` can be cast into `ZeroHom` via
`ZeroHomClass.toZeroHom`. "]
instance [OneHomClass F M N] : CoeTC F (OneHom M N) 
goal: CoeTC F (OneHom M N)

full_name: instCoeTCZeroHomOfZeroHomClass
code: /-- Any type satisfying `OneHomClass` can be cast into `OneHom` via `OneHomClass.toOneHom`. -/
@[to_additive "Any type satisfying `ZeroHomClass` can be cast into `ZeroHom` via
`ZeroHomClass.toZeroHom`. "]
instance [OneHomClass F M N] : CoeTC F (OneHom M N) 
goal: CoeTC F (ZeroHom M N)

full_name: OneHom.coe_coe
code: @[to_additive (attr := simp)]
theorem OneHom.coe_coe [OneHomClass F M N] (f : F) :
    ((f : OneHom M N) : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: ZeroHom.coe_coe
code: @[to_additive (attr := simp)]
theorem OneHom.coe_coe [OneHomClass F M N] (f : F) :
    ((f : OneHom M N) : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: MulHom.map_mul'
code: /-- `M →ₙ* N` is the type of functions `M → N` that preserve multiplication. The `ₙ` in the notation
stands for "non-unital" because it is intended to match the notation for `NonUnitalAlgHom` and
`NonUnitalRingHom`, so a `MulHom` is a non-unital monoid hom.

When possible, instead of parametrizing results over `(f : M →ₙ* N)`,
you should parametrize over `(F : Type*) [MulHomClass F M N] (f : F)`.
When you extend this structure, make sure to extend `MulHomClass`.
-/
@[to_additive]
structure MulHom (M : Type*) (N : Type*) [Mul M] [Mul N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves multiplication -/
  protected map_mul' : ∀ x y, toFun (x * y) = toFun x * toFun y
goal: self.toFun (x * y) = self.toFun x * self.toFun y

full_name: MulHom.toFun
code: /-- `M →ₙ* N` is the type of functions `M → N` that preserve multiplication. The `ₙ` in the notation
stands for "non-unital" because it is intended to match the notation for `NonUnitalAlgHom` and
`NonUnitalRingHom`, so a `MulHom` is a non-unital monoid hom.

When possible, instead of parametrizing results over `(f : M →ₙ* N)`,
you should parametrize over `(F : Type*) [MulHomClass F M N] (f : F)`.
When you extend this structure, make sure to extend `MulHomClass`.
-/
@[to_additive]
structure MulHom (M : Type*) (N : Type*) [Mul M] [Mul N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves multiplication -/
  protected map_mul' : ∀ x y, toFun (x * y) = toFun x * toFun y
goal: M → N

full_name: MulHom
code: /-- `M →ₙ* N` is the type of functions `M → N` that preserve multiplication. The `ₙ` in the notation
stands for "non-unital" because it is intended to match the notation for `NonUnitalAlgHom` and
`NonUnitalRingHom`, so a `MulHom` is a non-unital monoid hom.

When possible, instead of parametrizing results over `(f : M →ₙ* N)`,
you should parametrize over `(F : Type*) [MulHomClass F M N] (f : F)`.
When you extend this structure, make sure to extend `MulHomClass`.
-/
@[to_additive]
structure MulHom (M : Type*) (N : Type*) [Mul M] [Mul N] where
  /-- The underlying function -/
  protected toFun : M → N
  /-- The proposition that the function preserves multiplication -/
  protected map_mul' : ∀ x y, toFun (x * y) = toFun x * toFun y
goal: Type (max u_10 u_11)

full_name: _aux_Mathlib_Algebra_Group_Hom_Defs___unexpand_MulHom_1
code: /-- `M →ₙ* N` denotes the type of multiplication-preserving maps from `M` to `N`. -/
infixr:25 " →ₙ* " => MulHom
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Group_Hom_Defs___macroRules_term_→ₙ*__1»
code: /-- `M →ₙ* N` denotes the type of multiplication-preserving maps from `M` to `N`. -/
infixr:25 " →ₙ* " => MulHom
goal: Lean.Macro

full_name: MulHomClass.map_mul
code: /-- `MulHomClass F M N` states that `F` is a type of multiplication-preserving homomorphisms.

You should declare an instance of this typeclass when you extend `MulHom`.
-/
@[to_additive]
class MulHomClass (F : Type*) (M N : outParam Type*) [Mul M] [Mul N] [FunLike F M N] : Prop where
  /-- The proposition that the function preserves multiplication -/
  map_mul : ∀ (f : F) (x y : M), f (x * y) = f x * f y
goal: f (x * y) = f x * f y

full_name: MulHomClass
code: /-- `MulHomClass F M N` states that `F` is a type of multiplication-preserving homomorphisms.

You should declare an instance of this typeclass when you extend `MulHom`.
-/
@[to_additive]
class MulHomClass (F : Type*) (M N : outParam Type*) [Mul M] [Mul N] [FunLike F M N] : Prop where
  /-- The proposition that the function preserves multiplication -/
  map_mul : ∀ (f : F) (x y : M), f (x * y) = f x * f y
goal: Prop

full_name: AddHom.funLike
code: @[to_additive]
instance MulHom.funLike : FunLike (M →ₙ* N) M N 
goal: FunLike (AddHom M N) M N

full_name: MulHom.funLike
code: @[to_additive]
instance MulHom.funLike : FunLike (M →ₙ* N) M N 
goal: FunLike (M →ₙ* N) M N

full_name: MulHom.mulHomClass
code: /-- `MulHom` is a type of multiplication-preserving homomorphisms -/
@[to_additive "`AddHom` is a type of addition-preserving homomorphisms"]
instance MulHom.mulHomClass : MulHomClass (M →ₙ* N) M N 
goal: MulHomClass (M →ₙ* N) M N

full_name: AddHom.addHomClass
code: /-- `MulHom` is a type of multiplication-preserving homomorphisms -/
@[to_additive "`AddHom` is a type of addition-preserving homomorphisms"]
instance MulHom.mulHomClass : MulHomClass (M →ₙ* N) M N 
goal: AddHomClass (AddHom M N) M N

full_name: map_add
code: @[to_additive (attr := simp)]
theorem map_mul [MulHomClass F M N] (f : F) (x y : M) : f (x * y) = f x * f y 
goal: f (x + y) = f x + f y

full_name: map_mul
code: @[to_additive (attr := simp)]
theorem map_mul [MulHomClass F M N] (f : F) (x y : M) : f (x * y) = f x * f y 
goal: f (x * y) = f x * f y

full_name: map_comp_mul
code: @[to_additive (attr := simp)]
lemma map_comp_mul [MulHomClass F M N] (f : F) (g h : ι → M) : f ∘ (g * h) = f ∘ g * f ∘ h 
goal: ⇑f ∘ (g * h) = ⇑f ∘ g * ⇑f ∘ h

full_name: map_comp_add
code: @[to_additive (attr := simp)]
lemma map_comp_mul [MulHomClass F M N] (f : F) (g h : ι → M) : f ∘ (g * h) = f ∘ g * f ∘ h 
goal: ⇑f ∘ (g + h) = ⇑f ∘ g + ⇑f ∘ h

full_name: MulHomClass.toMulHom
code: /-- Turn an element of a type `F` satisfying `MulHomClass F M N` into an actual
`MulHom`. This is declared as the default coercion from `F` to `M →ₙ* N`. -/
@[to_additive (attr := coe)
"Turn an element of a type `F` satisfying `AddHomClass F M N` into an actual
`AddHom`. This is declared as the default coercion from `F` to `M →ₙ+ N`."]
def MulHomClass.toMulHom [MulHomClass F M N] (f : F) : M →ₙ* N 
goal: M →ₙ* N

full_name: AddHomClass.toAddHom
code: /-- Turn an element of a type `F` satisfying `MulHomClass F M N` into an actual
`MulHom`. This is declared as the default coercion from `F` to `M →ₙ* N`. -/
@[to_additive (attr := coe)
"Turn an element of a type `F` satisfying `AddHomClass F M N` into an actual
`AddHom`. This is declared as the default coercion from `F` to `M →ₙ+ N`."]
def MulHomClass.toMulHom [MulHomClass F M N] (f : F) : M →ₙ* N 
goal: AddHom M N

full_name: instCoeTCAddHomOfAddHomClass
code: /-- Any type satisfying `MulHomClass` can be cast into `MulHom` via `MulHomClass.toMulHom`. -/
@[to_additive "Any type satisfying `AddHomClass` can be cast into `AddHom` via
`AddHomClass.toAddHom`."]
instance [MulHomClass F M N] : CoeTC F (M →ₙ* N) 
goal: CoeTC F (AddHom M N)

full_name: instCoeTCMulHomOfMulHomClass
code: /-- Any type satisfying `MulHomClass` can be cast into `MulHom` via `MulHomClass.toMulHom`. -/
@[to_additive "Any type satisfying `AddHomClass` can be cast into `AddHom` via
`AddHomClass.toAddHom`."]
instance [MulHomClass F M N] : CoeTC F (M →ₙ* N) 
goal: CoeTC F (M →ₙ* N)

full_name: MulHom.coe_coe
code: @[to_additive (attr := simp)]
theorem MulHom.coe_coe [MulHomClass F M N] (f : F) : ((f : MulHom M N) : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: AddHom.coe_coe
code: @[to_additive (attr := simp)]
theorem MulHom.coe_coe [MulHomClass F M N] (f : F) : ((f : MulHom M N) : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: MonoidHom
code: /-- `M →* N` is the type of functions `M → N` that preserve the `Monoid` structure.
`MonoidHom` is also used for group homomorphisms.

When possible, instead of parametrizing results over `(f : M →+ N)`,
you should parametrize over `(F : Type*) [MonoidHomClass F M N] (f : F)`.

When you extend this structure, make sure to extend `MonoidHomClass`.
-/
@[to_additive]
structure MonoidHom (M : Type*) (N : Type*) [MulOneClass M] [MulOneClass N] extends
  OneHom M N, M →ₙ* N
goal: Type (max u_10 u_11)

full_name: «_aux_Mathlib_Algebra_Group_Hom_Defs___macroRules_term_→*__1»
code: /-- `M →* N` denotes the type of monoid homomorphisms from `M` to `N`. -/
infixr:25 " →* " => MonoidHom
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Group_Hom_Defs___unexpand_MonoidHom_1
code: /-- `M →* N` denotes the type of monoid homomorphisms from `M` to `N`. -/
infixr:25 " →* " => MonoidHom
goal: Lean.PrettyPrinter.Unexpander

full_name: MonoidHomClass
code: /-- `MonoidHomClass F M N` states that `F` is a type of `Monoid`-preserving homomorphisms.
You should also extend this typeclass when you extend `MonoidHom`. -/
@[to_additive]
class MonoidHomClass (F : Type*) (M N : outParam Type*) [MulOneClass M] [MulOneClass N]
  [FunLike F M N]
  extends MulHomClass F M N, OneHomClass F M N : Prop
goal: Prop

full_name: MonoidHom.instFunLike
code: @[to_additive]
instance MonoidHom.instFunLike : FunLike (M →* N) M N 
goal: FunLike (M →* N) M N

full_name: AddMonoidHom.instFunLike
code: @[to_additive]
instance MonoidHom.instFunLike : FunLike (M →* N) M N 
goal: FunLike (M →+ N) M N

full_name: MonoidHom.instMonoidHomClass
code: @[to_additive]
instance MonoidHom.instMonoidHomClass : MonoidHomClass (M →* N) M N 
goal: MonoidHomClass (M →* N) M N

full_name: AddMonoidHom.instAddMonoidHomClass
code: @[to_additive]
instance MonoidHom.instMonoidHomClass : MonoidHomClass (M →* N) M N 
goal: AddMonoidHomClass (M →+ N) M N

full_name: instSubsingletonMonoidHom
code: @[to_additive] instance [Subsingleton M] : Subsingleton (M →* N) 
goal: Subsingleton (M →* N)

full_name: instSubsingletonAddMonoidHom
code: @[to_additive] instance [Subsingleton M] : Subsingleton (M →* N) 
goal: Subsingleton (M →+ N)

full_name: AddMonoidHomClass.toAddMonoidHom
code: /-- Turn an element of a type `F` satisfying `MonoidHomClass F M N` into an actual
`MonoidHom`. This is declared as the default coercion from `F` to `M →* N`. -/
@[to_additive (attr := coe)
"Turn an element of a type `F` satisfying `AddMonoidHomClass F M N` into an
actual `MonoidHom`. This is declared as the default coercion from `F` to `M →+ N`."]
def MonoidHomClass.toMonoidHom [MonoidHomClass F M N] (f : F) : M →* N 
goal: M →+ N

full_name: MonoidHomClass.toMonoidHom
code: /-- Turn an element of a type `F` satisfying `MonoidHomClass F M N` into an actual
`MonoidHom`. This is declared as the default coercion from `F` to `M →* N`. -/
@[to_additive (attr := coe)
"Turn an element of a type `F` satisfying `AddMonoidHomClass F M N` into an
actual `MonoidHom`. This is declared as the default coercion from `F` to `M →+ N`."]
def MonoidHomClass.toMonoidHom [MonoidHomClass F M N] (f : F) : M →* N 
goal: M →* N

full_name: instCoeTCMonoidHomOfMonoidHomClass
code: /-- Any type satisfying `MonoidHomClass` can be cast into `MonoidHom` via
`MonoidHomClass.toMonoidHom`. -/
@[to_additive "Any type satisfying `AddMonoidHomClass` can be cast into `AddMonoidHom` via
`AddMonoidHomClass.toAddMonoidHom`."]
instance [MonoidHomClass F M N] : CoeTC F (M →* N) 
goal: CoeTC F (M →* N)

full_name: instCoeTCAddMonoidHomOfAddMonoidHomClass
code: /-- Any type satisfying `MonoidHomClass` can be cast into `MonoidHom` via
`MonoidHomClass.toMonoidHom`. -/
@[to_additive "Any type satisfying `AddMonoidHomClass` can be cast into `AddMonoidHom` via
`AddMonoidHomClass.toAddMonoidHom`."]
instance [MonoidHomClass F M N] : CoeTC F (M →* N) 
goal: CoeTC F (M →+ N)

full_name: AddMonoidHom.coe_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_coe [MonoidHomClass F M N] (f : F) : ((f : M →* N) : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: MonoidHom.coe_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_coe [MonoidHomClass F M N] (f : F) : ((f : M →* N) : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: map_mul_eq_one
code: @[to_additive]
theorem map_mul_eq_one [MonoidHomClass F M N] (f : F) {a b : M} (h : a * b = 1) :
    f a * f b = 1 
goal: f a * f b = 1

full_name: map_add_eq_zero
code: @[to_additive]
theorem map_mul_eq_one [MonoidHomClass F M N] (f : F) {a b : M} (h : a * b = 1) :
    f a * f b = 1 
goal: f a + f b = 0

full_name: map_sub'
code: @[to_additive]
theorem map_div' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H]
    (f : F) (hf : ∀ a, f a⁻¹ = (f a)⁻¹) (a b : G) : f (a / b) = f a / f b 
goal: f (a - b) = f a - f b

full_name: map_div'
code: @[to_additive]
theorem map_div' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H]
    (f : F) (hf : ∀ a, f a⁻¹ = (f a)⁻¹) (a b : G) : f (a / b) = f a / f b 
goal: f (a / b) = f a / f b

full_name: map_comp_div'
code: @[to_additive]
lemma map_comp_div' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H] (f : F)
    (hf : ∀ a, f a⁻¹ = (f a)⁻¹) (g h : ι → G) : f ∘ (g / h) = f ∘ g / f ∘ h 
goal: ⇑f ∘ (g / h) = ⇑f ∘ g / ⇑f ∘ h

full_name: map_comp_sub'
code: @[to_additive]
lemma map_comp_div' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H] (f : F)
    (hf : ∀ a, f a⁻¹ = (f a)⁻¹) (g h : ι → G) : f ∘ (g / h) = f ∘ g / f ∘ h 
goal: ⇑f ∘ (g - h) = ⇑f ∘ g - ⇑f ∘ h

full_name: map_inv
code: /-- Group homomorphisms preserve inverse. -/
@[to_additive (attr := simp) "Additive group homomorphisms preserve negation."]
theorem map_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H]
    (f : F) (a : G) : f a⁻¹ = (f a)⁻¹ 
goal: f a⁻¹ = (f a)⁻¹

full_name: map_neg
code: /-- Group homomorphisms preserve inverse. -/
@[to_additive (attr := simp) "Additive group homomorphisms preserve negation."]
theorem map_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H]
    (f : F) (a : G) : f a⁻¹ = (f a)⁻¹ 
goal: f (-a) = -f a

full_name: map_comp_inv
code: @[to_additive (attr := simp)]
lemma map_comp_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G) :
    f ∘ g⁻¹ = (f ∘ g)⁻¹ 
goal: ⇑f ∘ g⁻¹ = (⇑f ∘ g)⁻¹

full_name: map_comp_neg
code: @[to_additive (attr := simp)]
lemma map_comp_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G) :
    f ∘ g⁻¹ = (f ∘ g)⁻¹ 
goal: ⇑f ∘ (-g) = -⇑f ∘ g

full_name: map_add_neg
code: /-- Group homomorphisms preserve division. -/
@[to_additive "Additive group homomorphisms preserve subtraction."]
theorem map_mul_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (a b : G) :
    f (a * b⁻¹) = f a * (f b)⁻¹ 
goal: f (a + -b) = f a + -f b

full_name: map_mul_inv
code: /-- Group homomorphisms preserve division. -/
@[to_additive "Additive group homomorphisms preserve subtraction."]
theorem map_mul_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (a b : G) :
    f (a * b⁻¹) = f a * (f b)⁻¹ 
goal: f (a * b⁻¹) = f a * (f b)⁻¹

full_name: map_comp_mul_inv
code: @[to_additive]
lemma map_comp_mul_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g h : ι → G) :
    f ∘ (g * h⁻¹) = f ∘ g * (f ∘ h)⁻¹ 
goal: ⇑f ∘ (g * h⁻¹) = ⇑f ∘ g * (⇑f ∘ h)⁻¹

full_name: map_comp_add_neg
code: @[to_additive]
lemma map_comp_mul_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g h : ι → G) :
    f ∘ (g * h⁻¹) = f ∘ g * (f ∘ h)⁻¹ 
goal: ⇑f ∘ (g + -h) = ⇑f ∘ g + -⇑f ∘ h

full_name: map_sub
code: /-- Group homomorphisms preserve division. -/
@[to_additive (attr := simp) "Additive group homomorphisms preserve subtraction."]
theorem map_div [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) :
    ∀ a b, f (a / b) = f a / f b 
goal: f (a - b) = f a - f b

full_name: map_div
code: /-- Group homomorphisms preserve division. -/
@[to_additive (attr := simp) "Additive group homomorphisms preserve subtraction."]
theorem map_div [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) :
    ∀ a b, f (a / b) = f a / f b 
goal: f (a / b) = f a / f b

full_name: map_comp_div
code: @[to_additive (attr := simp)]
lemma map_comp_div [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g h : ι → G) :
    f ∘ (g / h) = f ∘ g / f ∘ h 
goal: ⇑f ∘ (g / h) = ⇑f ∘ g / ⇑f ∘ h

full_name: map_comp_sub
code: @[to_additive (attr := simp)]
lemma map_comp_div [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g h : ι → G) :
    f ∘ (g / h) = f ∘ g / f ∘ h 
goal: ⇑f ∘ (g - h) = ⇑f ∘ g - ⇑f ∘ h

full_name: map_nsmul
code: @[to_additive (attr := simp) (reorder := 9 10)]
theorem map_pow [Monoid G] [Monoid H] [MonoidHomClass F G H] (f : F) (a : G) :
    ∀ n : ℕ, f (a ^ n) = f a ^ n
  
goal: f (n • a) = n • f a

full_name: map_pow
code: @[to_additive (attr := simp) (reorder := 9 10)]
theorem map_pow [Monoid G] [Monoid H] [MonoidHomClass F G H] (f : F) (a : G) :
    ∀ n : ℕ, f (a ^ n) = f a ^ n
  
goal: f (a ^ n) = f a ^ n

full_name: map_comp_nsmul
code: @[to_additive (attr := simp)]
lemma map_comp_pow [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G) (n : ℕ) :
    f ∘ (g ^ n) = f ∘ g ^ n 
goal: ⇑f ∘ (n • g) = n • ⇑f ∘ g

full_name: map_comp_pow
code: @[to_additive (attr := simp)]
lemma map_comp_pow [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G) (n : ℕ) :
    f ∘ (g ^ n) = f ∘ g ^ n 
goal: ⇑f ∘ (g ^ n) = ⇑f ∘ g ^ n

full_name: map_zsmul'
code: @[to_additive]
theorem map_zpow' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H]
    (f : F) (hf : ∀ x : G, f x⁻¹ = (f x)⁻¹) (a : G) : ∀ n : ℤ, f (a ^ n) = f a ^ n
  
goal: f (n • a) = n • f a

full_name: map_zpow'
code: @[to_additive]
theorem map_zpow' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H]
    (f : F) (hf : ∀ x : G, f x⁻¹ = (f x)⁻¹) (a : G) : ∀ n : ℤ, f (a ^ n) = f a ^ n
  
goal: f (a ^ n) = f a ^ n

full_name: map_comp_zpow'
code: @[to_additive (attr := simp)]
lemma map_comp_zpow' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H] (f : F)
    (hf : ∀ x : G, f x⁻¹ = (f x)⁻¹) (g : ι → G) (n : ℤ) : f ∘ (g ^ n) = f ∘ g ^ n 
goal: ⇑f ∘ (g ^ n) = ⇑f ∘ g ^ n

full_name: map_comp_zsmul'
code: @[to_additive (attr := simp)]
lemma map_comp_zpow' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H] (f : F)
    (hf : ∀ x : G, f x⁻¹ = (f x)⁻¹) (g : ι → G) (n : ℤ) : f ∘ (g ^ n) = f ∘ g ^ n 
goal: ⇑f ∘ (n • g) = n • ⇑f ∘ g

full_name: map_zpow
code: /-- Group homomorphisms preserve integer power. -/
@[to_additive (attr := simp) (reorder := 9 10)
"Additive group homomorphisms preserve integer scaling."]
theorem map_zpow [Group G] [DivisionMonoid H] [MonoidHomClass F G H]
    (f : F) (g : G) (n : ℤ) : f (g ^ n) = f g ^ n 
goal: f (g ^ n) = f g ^ n

full_name: map_zsmul
code: /-- Group homomorphisms preserve integer power. -/
@[to_additive (attr := simp) (reorder := 9 10)
"Additive group homomorphisms preserve integer scaling."]
theorem map_zpow [Group G] [DivisionMonoid H] [MonoidHomClass F G H]
    (f : F) (g : G) (n : ℤ) : f (g ^ n) = f g ^ n 
goal: f (n • g) = n • f g

full_name: map_comp_zsmul
code: @[to_additive]
lemma map_comp_zpow [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G)
    (n : ℤ) : f ∘ (g ^ n) = f ∘ g ^ n 
goal: ⇑f ∘ (n • g) = n • ⇑f ∘ g

full_name: map_comp_zpow
code: @[to_additive]
lemma map_comp_zpow [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G)
    (n : ℤ) : f ∘ (g ^ n) = f ∘ g ^ n 
goal: ⇑f ∘ (g ^ n) = ⇑f ∘ g ^ n

full_name: AddMonoidHom.coeToZeroHom
code: /-- `MonoidHom` down-cast to a `OneHom`, forgetting the multiplicative property. -/
@[to_additive "`AddMonoidHom` down-cast to a `ZeroHom`, forgetting the additive property"]
instance MonoidHom.coeToOneHom [MulOneClass M] [MulOneClass N] :
  Coe (M →* N) (OneHom M N) 
goal: Coe (M →+ N) (ZeroHom M N)

full_name: MonoidHom.coeToOneHom
code: /-- `MonoidHom` down-cast to a `OneHom`, forgetting the multiplicative property. -/
@[to_additive "`AddMonoidHom` down-cast to a `ZeroHom`, forgetting the additive property"]
instance MonoidHom.coeToOneHom [MulOneClass M] [MulOneClass N] :
  Coe (M →* N) (OneHom M N) 
goal: Coe (M →* N) (OneHom M N)

full_name: MonoidHom.coeToMulHom
code: /-- `MonoidHom` down-cast to a `MulHom`, forgetting the 1-preserving property. -/
@[to_additive "`AddMonoidHom` down-cast to an `AddHom`, forgetting the 0-preserving property."]
instance MonoidHom.coeToMulHom [MulOneClass M] [MulOneClass N] :
  Coe (M →* N) (M →ₙ* N) 
goal: Coe (M →* N) (M →ₙ* N)

full_name: AddMonoidHom.coeToAddHom
code: /-- `MonoidHom` down-cast to a `MulHom`, forgetting the 1-preserving property. -/
@[to_additive "`AddMonoidHom` down-cast to an `AddHom`, forgetting the 0-preserving property."]
instance MonoidHom.coeToMulHom [MulOneClass M] [MulOneClass N] :
  Coe (M →* N) (M →ₙ* N) 
goal: Coe (M →+ N) (AddHom M N)

full_name: ZeroHom.coe_mk
code: @[to_additive (attr := simp)]
theorem OneHom.coe_mk [One M] [One N] (f : M → N) (h1) : (OneHom.mk f h1 : M → N) = f 
goal: ⇑{ toFun := f, map_zero' := h1 } = f

full_name: OneHom.coe_mk
code: @[to_additive (attr := simp)]
theorem OneHom.coe_mk [One M] [One N] (f : M → N) (h1) : (OneHom.mk f h1 : M → N) = f 
goal: ⇑{ toFun := f, map_one' := h1 } = f

full_name: ZeroHom.toFun_eq_coe
code: @[to_additive (attr := simp)]
theorem OneHom.toFun_eq_coe [One M] [One N] (f : OneHom M N) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: OneHom.toFun_eq_coe
code: @[to_additive (attr := simp)]
theorem OneHom.toFun_eq_coe [One M] [One N] (f : OneHom M N) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: MulHom.coe_mk
code: @[to_additive (attr := simp)]
theorem MulHom.coe_mk [Mul M] [Mul N] (f : M → N) (hmul) : (MulHom.mk f hmul : M → N) = f 
goal: ⇑{ toFun := f, map_mul' := hmul } = f

full_name: AddHom.coe_mk
code: @[to_additive (attr := simp)]
theorem MulHom.coe_mk [Mul M] [Mul N] (f : M → N) (hmul) : (MulHom.mk f hmul : M → N) = f 
goal: ⇑{ toFun := f, map_add' := hmul } = f

full_name: AddHom.toFun_eq_coe
code: @[to_additive (attr := simp)]
theorem MulHom.toFun_eq_coe [Mul M] [Mul N] (f : M →ₙ* N) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: MulHom.toFun_eq_coe
code: @[to_additive (attr := simp)]
theorem MulHom.toFun_eq_coe [Mul M] [Mul N] (f : M →ₙ* N) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: MonoidHom.coe_mk
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_mk [MulOneClass M] [MulOneClass N] (f hmul) :
    (MonoidHom.mk f hmul : M → N) = f 
goal: ⇑{ toOneHom := f, map_mul' := hmul } = ⇑f

full_name: AddMonoidHom.coe_mk
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_mk [MulOneClass M] [MulOneClass N] (f hmul) :
    (MonoidHom.mk f hmul : M → N) = f 
goal: ⇑{ toZeroHom := f, map_add' := hmul } = ⇑f

full_name: MonoidHom.toOneHom_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.toOneHom_coe [MulOneClass M] [MulOneClass N] (f : M →* N) :
    (f.toOneHom : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: AddMonoidHom.toZeroHom_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.toOneHom_coe [MulOneClass M] [MulOneClass N] (f : M →* N) :
    (f.toOneHom : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: AddMonoidHom.toAddHom_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.toMulHom_coe [MulOneClass M] [MulOneClass N] (f : M →* N) :
    f.toMulHom.toFun = f 
goal: (↑f).toFun = ⇑f

full_name: MonoidHom.toMulHom_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.toMulHom_coe [MulOneClass M] [MulOneClass N] (f : M →* N) :
    f.toMulHom.toFun = f 
goal: (↑f).toFun = ⇑f

full_name: AddMonoidHom.toFun_eq_coe
code: @[to_additive]
theorem MonoidHom.toFun_eq_coe [MulOneClass M] [MulOneClass N] (f : M →* N) : f.toFun = f 
goal: (↑f).toFun = ⇑f

full_name: MonoidHom.toFun_eq_coe
code: @[to_additive]
theorem MonoidHom.toFun_eq_coe [MulOneClass M] [MulOneClass N] (f : M →* N) : f.toFun = f 
goal: (↑f).toFun = ⇑f

full_name: ZeroHom.ext
code: @[to_additive (attr := ext)]
theorem OneHom.ext [One M] [One N] ⦃f g : OneHom M N⦄ (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: OneHom.ext
code: @[to_additive (attr := ext)]
theorem OneHom.ext [One M] [One N] ⦃f g : OneHom M N⦄ (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: MulHom.ext
code: @[to_additive (attr := ext)]
theorem MulHom.ext [Mul M] [Mul N] ⦃f g : M →ₙ* N⦄ (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: AddHom.ext
code: @[to_additive (attr := ext)]
theorem MulHom.ext [Mul M] [Mul N] ⦃f g : M →ₙ* N⦄ (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: AddMonoidHom.ext
code: @[to_additive (attr := ext)]
theorem MonoidHom.ext [MulOneClass M] [MulOneClass N] ⦃f g : M →* N⦄ (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: MonoidHom.ext
code: @[to_additive (attr := ext)]
theorem MonoidHom.ext [MulOneClass M] [MulOneClass N] ⦃f g : M →* N⦄ (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: MonoidHom.mk'_apply
code: /-- Makes a group homomorphism from a proof that the map preserves multiplication. -/
@[to_additive (attr := simps (config := .asFn))
  "Makes an additive group homomorphism from a proof that the map preserves addition."]
def mk' (f : M → G) (map_mul : ∀ a b : M, f (a * b) = f a * f b) : M →* G 
goal: ⇑(MonoidHom.mk' f map_mul) = f

full_name: AddMonoidHom.mk'
code: /-- Makes a group homomorphism from a proof that the map preserves multiplication. -/
@[to_additive (attr := simps (config := .asFn))
  "Makes an additive group homomorphism from a proof that the map preserves addition."]
def mk' (f : M → G) (map_mul : ∀ a b : M, f (a * b) = f a * f b) : M →* G 
goal: M →+ G

full_name: AddMonoidHom.mk'_apply
code: /-- Makes a group homomorphism from a proof that the map preserves multiplication. -/
@[to_additive (attr := simps (config := .asFn))
  "Makes an additive group homomorphism from a proof that the map preserves addition."]
def mk' (f : M → G) (map_mul : ∀ a b : M, f (a * b) = f a * f b) : M →* G 
goal: ⇑(AddMonoidHom.mk' f map_mul) = f

full_name: MonoidHom.mk'
code: /-- Makes a group homomorphism from a proof that the map preserves multiplication. -/
@[to_additive (attr := simps (config := .asFn))
  "Makes an additive group homomorphism from a proof that the map preserves addition."]
def mk' (f : M → G) (map_mul : ∀ a b : M, f (a * b) = f a * f b) : M →* G 
goal: M →* G

full_name: ZeroHom.mk_coe
code: @[to_additive (attr := simp)]
theorem OneHom.mk_coe [One M] [One N] (f : OneHom M N) (h1) : OneHom.mk f h1 = f 
goal: { toFun := ⇑f, map_zero' := h1 } = f

full_name: OneHom.mk_coe
code: @[to_additive (attr := simp)]
theorem OneHom.mk_coe [One M] [One N] (f : OneHom M N) (h1) : OneHom.mk f h1 = f 
goal: { toFun := ⇑f, map_one' := h1 } = f

full_name: MulHom.mk_coe
code: @[to_additive (attr := simp)]
theorem MulHom.mk_coe [Mul M] [Mul N] (f : M →ₙ* N) (hmul) : MulHom.mk f hmul = f 
goal: { toFun := ⇑f, map_mul' := hmul } = f

full_name: AddHom.mk_coe
code: @[to_additive (attr := simp)]
theorem MulHom.mk_coe [Mul M] [Mul N] (f : M →ₙ* N) (hmul) : MulHom.mk f hmul = f 
goal: { toFun := ⇑f, map_add' := hmul } = f

full_name: AddMonoidHom.mk_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.mk_coe [MulOneClass M] [MulOneClass N] (f : M →* N) (hmul) :
    MonoidHom.mk f hmul = f 
goal: { toZeroHom := ↑f, map_add' := hmul } = f

full_name: MonoidHom.mk_coe
code: @[to_additive (attr := simp)]
theorem MonoidHom.mk_coe [MulOneClass M] [MulOneClass N] (f : M →* N) (hmul) :
    MonoidHom.mk f hmul = f 
goal: { toOneHom := ↑f, map_mul' := hmul } = f

full_name: ZeroHom.copy
code: /-- Copy of a `OneHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
@[to_additive
  "Copy of a `ZeroHom` with a new `toFun` equal to the old one. Useful to fix
  definitional equalities."]
protected def OneHom.copy [One M] [One N] (f : OneHom M N) (f' : M → N) (h : f' = f) :
    OneHom M N 
goal: ZeroHom M N

full_name: OneHom.copy
code: /-- Copy of a `OneHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
@[to_additive
  "Copy of a `ZeroHom` with a new `toFun` equal to the old one. Useful to fix
  definitional equalities."]
protected def OneHom.copy [One M] [One N] (f : OneHom M N) (f' : M → N) (h : f' = f) :
    OneHom M N 
goal: OneHom M N

full_name: ZeroHom.coe_copy
code: @[to_additive (attr := simp)]
theorem OneHom.coe_copy {_ : One M} {_ : One N} (f : OneHom M N) (f' : M → N) (h : f' = f) :
    (f.copy f' h) = f' 
goal: ∀ {x : Zero M} {x_1 : Zero N} (f : ZeroHom M N) (f' : M → N) (h : f' = ⇑f), ⇑(f.copy f' h) = f'

full_name: OneHom.coe_copy
code: @[to_additive (attr := simp)]
theorem OneHom.coe_copy {_ : One M} {_ : One N} (f : OneHom M N) (f' : M → N) (h : f' = f) :
    (f.copy f' h) = f' 
goal: ∀ {x : One M} {x_1 : One N} (f : OneHom M N) (f' : M → N) (h : f' = ⇑f), ⇑(f.copy f' h) = f'

full_name: ZeroHom.coe_copy_eq
code: @[to_additive]
theorem OneHom.coe_copy_eq {_ : One M} {_ : One N} (f : OneHom M N) (f' : M → N) (h : f' = f) :
    f.copy f' h = f 
goal: ∀ {x : Zero M} {x_1 : Zero N} (f : ZeroHom M N) (f' : M → N) (h : f' = ⇑f), f.copy f' h = f

full_name: OneHom.coe_copy_eq
code: @[to_additive]
theorem OneHom.coe_copy_eq {_ : One M} {_ : One N} (f : OneHom M N) (f' : M → N) (h : f' = f) :
    f.copy f' h = f 
goal: ∀ {x : One M} {x_1 : One N} (f : OneHom M N) (f' : M → N) (h : f' = ⇑f), f.copy f' h = f

full_name: MulHom.copy
code: /-- Copy of a `MulHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
@[to_additive
  "Copy of an `AddHom` with a new `toFun` equal to the old one. Useful to fix
  definitional equalities."]
protected def MulHom.copy [Mul M] [Mul N] (f : M →ₙ* N) (f' : M → N) (h : f' = f) :
    M →ₙ* N 
goal: M →ₙ* N

full_name: AddHom.copy
code: /-- Copy of a `MulHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
@[to_additive
  "Copy of an `AddHom` with a new `toFun` equal to the old one. Useful to fix
  definitional equalities."]
protected def MulHom.copy [Mul M] [Mul N] (f : M →ₙ* N) (f' : M → N) (h : f' = f) :
    M →ₙ* N 
goal: AddHom M N

full_name: MulHom.coe_copy
code: @[to_additive (attr := simp)]
theorem MulHom.coe_copy {_ : Mul M} {_ : Mul N} (f : M →ₙ* N) (f' : M → N) (h : f' = f) :
    (f.copy f' h) = f' 
goal: ∀ {x : Mul M} {x_1 : Mul N} (f : M →ₙ* N) (f' : M → N) (h : f' = ⇑f), ⇑(f.copy f' h) = f'

full_name: AddHom.coe_copy
code: @[to_additive (attr := simp)]
theorem MulHom.coe_copy {_ : Mul M} {_ : Mul N} (f : M →ₙ* N) (f' : M → N) (h : f' = f) :
    (f.copy f' h) = f' 
goal: ∀ {x : Add M} {x_1 : Add N} (f : AddHom M N) (f' : M → N) (h : f' = ⇑f), ⇑(f.copy f' h) = f'

full_name: AddHom.coe_copy_eq
code: @[to_additive]
theorem MulHom.coe_copy_eq {_ : Mul M} {_ : Mul N} (f : M →ₙ* N) (f' : M → N) (h : f' = f) :
    f.copy f' h = f 
goal: ∀ {x : Add M} {x_1 : Add N} (f : AddHom M N) (f' : M → N) (h : f' = ⇑f), f.copy f' h = f

full_name: MulHom.coe_copy_eq
code: @[to_additive]
theorem MulHom.coe_copy_eq {_ : Mul M} {_ : Mul N} (f : M →ₙ* N) (f' : M → N) (h : f' = f) :
    f.copy f' h = f 
goal: ∀ {x : Mul M} {x_1 : Mul N} (f : M →ₙ* N) (f' : M → N) (h : f' = ⇑f), f.copy f' h = f

full_name: MonoidHom.copy
code: /-- Copy of a `MonoidHom` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
@[to_additive
  "Copy of an `AddMonoidHom` with a new `toFun` equal to the old one. Useful to fix
  definitional equalities."]
protected def MonoidHom.copy [MulOneClass M] [MulOneClass N] (f : M →* N) (f' : M → N)
    (h : f' = f) : M →* N 
goal: M →* N

full_name: AddMonoidHom.copy
code: /-- Copy of a `MonoidHom` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
@[to_additive
  "Copy of an `AddMonoidHom` with a new `toFun` equal to the old one. Useful to fix
  definitional equalities."]
protected def MonoidHom.copy [MulOneClass M] [MulOneClass N] (f : M →* N) (f' : M → N)
    (h : f' = f) : M →* N 
goal: M →+ N

full_name: AddMonoidHom.coe_copy
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_copy {_ : MulOneClass M} {_ : MulOneClass N} (f : M →* N) (f' : M → N)
    (h : f' = f) : (f.copy f' h) = f' 
goal: ∀ {x : AddZeroClass M} {x_1 : AddZeroClass N} (f : M →+ N) (f' : M → N) (h : f' = ⇑f), ⇑(f.copy f' h) = f'

full_name: MonoidHom.coe_copy
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_copy {_ : MulOneClass M} {_ : MulOneClass N} (f : M →* N) (f' : M → N)
    (h : f' = f) : (f.copy f' h) = f' 
goal: ∀ {x : MulOneClass M} {x_1 : MulOneClass N} (f : M →* N) (f' : M → N) (h : f' = ⇑f), ⇑(f.copy f' h) = f'

full_name: AddMonoidHom.copy_eq
code: @[to_additive]
theorem MonoidHom.copy_eq {_ : MulOneClass M} {_ : MulOneClass N} (f : M →* N) (f' : M → N)
    (h : f' = f) : f.copy f' h = f 
goal: ∀ {x : AddZeroClass M} {x_1 : AddZeroClass N} (f : M →+ N) (f' : M → N) (h : f' = ⇑f), f.copy f' h = f

full_name: MonoidHom.copy_eq
code: @[to_additive]
theorem MonoidHom.copy_eq {_ : MulOneClass M} {_ : MulOneClass N} (f : M →* N) (f' : M → N)
    (h : f' = f) : f.copy f' h = f 
goal: ∀ {x : MulOneClass M} {x_1 : MulOneClass N} (f : M →* N) (f' : M → N) (h : f' = ⇑f), f.copy f' h = f

full_name: OneHom.map_one
code: @[to_additive]
protected theorem OneHom.map_one [One M] [One N] (f : OneHom M N) : f 1 = 1 
goal: f 1 = 1

full_name: ZeroHom.map_zero
code: @[to_additive]
protected theorem OneHom.map_one [One M] [One N] (f : OneHom M N) : f 1 = 1 
goal: f 0 = 0

full_name: MonoidHom.map_one
code: /-- If `f` is a monoid homomorphism then `f 1 = 1`. -/
@[to_additive "If `f` is an additive monoid homomorphism then `f 0 = 0`."]
protected theorem MonoidHom.map_one [MulOneClass M] [MulOneClass N] (f : M →* N) : f 1 = 1 
goal: f 1 = 1

full_name: AddMonoidHom.map_zero
code: /-- If `f` is a monoid homomorphism then `f 1 = 1`. -/
@[to_additive "If `f` is an additive monoid homomorphism then `f 0 = 0`."]
protected theorem MonoidHom.map_one [MulOneClass M] [MulOneClass N] (f : M →* N) : f 1 = 1 
goal: f 0 = 0

full_name: MulHom.map_mul
code: @[to_additive]
protected theorem MulHom.map_mul [Mul M] [Mul N] (f : M →ₙ* N) (a b : M) : f (a * b) = f a * f b 
goal: f (a * b) = f a * f b

full_name: AddHom.map_add
code: @[to_additive]
protected theorem MulHom.map_mul [Mul M] [Mul N] (f : M →ₙ* N) (a b : M) : f (a * b) = f a * f b 
goal: f (a + b) = f a + f b

full_name: AddMonoidHom.map_add
code: /-- If `f` is a monoid homomorphism then `f (a * b) = f a * f b`. -/
@[to_additive "If `f` is an additive monoid homomorphism then `f (a + b) = f a + f b`."]
protected theorem MonoidHom.map_mul [MulOneClass M] [MulOneClass N] (f : M →* N) (a b : M) :
    f (a * b) = f a * f b 
goal: f (a + b) = f a + f b

full_name: MonoidHom.map_mul
code: /-- If `f` is a monoid homomorphism then `f (a * b) = f a * f b`. -/
@[to_additive "If `f` is an additive monoid homomorphism then `f (a + b) = f a + f b`."]
protected theorem MonoidHom.map_mul [MulOneClass M] [MulOneClass N] (f : M →* N) (a b : M) :
    f (a * b) = f a * f b 
goal: f (a * b) = f a * f b

full_name: AddMonoidHom.map_exists_right_neg
code: /-- Given a monoid homomorphism `f : M →* N` and an element `x : M`, if `x` has a right inverse,
then `f x` has a right inverse too. For elements invertible on both sides see `IsUnit.map`. -/
@[to_additive
  "Given an AddMonoid homomorphism `f : M →+ N` and an element `x : M`, if `x` has
  a right inverse, then `f x` has a right inverse too."]
theorem map_exists_right_inv (f : F) {x : M} (hx : ∃ y, x * y = 1) : ∃ y, f x * y = 1 
goal: ∃ y, f x + y = 0

full_name: MonoidHom.map_exists_right_inv
code: /-- Given a monoid homomorphism `f : M →* N` and an element `x : M`, if `x` has a right inverse,
then `f x` has a right inverse too. For elements invertible on both sides see `IsUnit.map`. -/
@[to_additive
  "Given an AddMonoid homomorphism `f : M →+ N` and an element `x : M`, if `x` has
  a right inverse, then `f x` has a right inverse too."]
theorem map_exists_right_inv (f : F) {x : M} (hx : ∃ y, x * y = 1) : ∃ y, f x * y = 1 
goal: ∃ y, f x * y = 1

full_name: MonoidHom.map_exists_left_inv
code: /-- Given a monoid homomorphism `f : M →* N` and an element `x : M`, if `x` has a left inverse,
then `f x` has a left inverse too. For elements invertible on both sides see `IsUnit.map`. -/
@[to_additive
  "Given an AddMonoid homomorphism `f : M →+ N` and an element `x : M`, if `x` has
  a left inverse, then `f x` has a left inverse too. For elements invertible on both sides see
  `IsAddUnit.map`."]
theorem map_exists_left_inv (f : F) {x : M} (hx : ∃ y, y * x = 1) : ∃ y, y * f x = 1 
goal: ∃ y, y * f x = 1

full_name: AddMonoidHom.map_exists_left_neg
code: /-- Given a monoid homomorphism `f : M →* N` and an element `x : M`, if `x` has a left inverse,
then `f x` has a left inverse too. For elements invertible on both sides see `IsUnit.map`. -/
@[to_additive
  "Given an AddMonoid homomorphism `f : M →+ N` and an element `x : M`, if `x` has
  a left inverse, then `f x` has a left inverse too. For elements invertible on both sides see
  `IsAddUnit.map`."]
theorem map_exists_left_inv (f : F) {x : M} (hx : ∃ y, y * x = 1) : ∃ y, y * f x = 1 
goal: ∃ y, y + f x = 0

full_name: ZeroHom.id
code: /-- The identity map from a type with 1 to itself. -/
@[to_additive (attr := simps) "The identity map from a type with zero to itself."]
def OneHom.id (M : Type*) [One M] : OneHom M M 
goal: ZeroHom M M

full_name: ZeroHom.id_apply
code: /-- The identity map from a type with 1 to itself. -/
@[to_additive (attr := simps) "The identity map from a type with zero to itself."]
def OneHom.id (M : Type*) [One M] : OneHom M M 
goal: (ZeroHom.id M) x = x

full_name: OneHom.id_apply
code: /-- The identity map from a type with 1 to itself. -/
@[to_additive (attr := simps) "The identity map from a type with zero to itself."]
def OneHom.id (M : Type*) [One M] : OneHom M M 
goal: (OneHom.id M) x = x

full_name: OneHom.id
code: /-- The identity map from a type with 1 to itself. -/
@[to_additive (attr := simps) "The identity map from a type with zero to itself."]
def OneHom.id (M : Type*) [One M] : OneHom M M 
goal: OneHom M M

full_name: MulHom.id_apply
code: /-- The identity map from a type with multiplication to itself. -/
@[to_additive (attr := simps) "The identity map from a type with addition to itself."]
def MulHom.id (M : Type*) [Mul M] : M →ₙ* M 
goal: (MulHom.id M) x = x

full_name: AddHom.id
code: /-- The identity map from a type with multiplication to itself. -/
@[to_additive (attr := simps) "The identity map from a type with addition to itself."]
def MulHom.id (M : Type*) [Mul M] : M →ₙ* M 
goal: AddHom M M

full_name: MulHom.id
code: /-- The identity map from a type with multiplication to itself. -/
@[to_additive (attr := simps) "The identity map from a type with addition to itself."]
def MulHom.id (M : Type*) [Mul M] : M →ₙ* M 
goal: M →ₙ* M

full_name: AddHom.id_apply
code: /-- The identity map from a type with multiplication to itself. -/
@[to_additive (attr := simps) "The identity map from a type with addition to itself."]
def MulHom.id (M : Type*) [Mul M] : M →ₙ* M 
goal: (AddHom.id M) x = x

full_name: AddMonoidHom.id
code: /-- The identity map from a monoid to itself. -/
@[to_additive (attr := simps) "The identity map from an additive monoid to itself."]
def MonoidHom.id (M : Type*) [MulOneClass M] : M →* M 
goal: M →+ M

full_name: MonoidHom.id
code: /-- The identity map from a monoid to itself. -/
@[to_additive (attr := simps) "The identity map from an additive monoid to itself."]
def MonoidHom.id (M : Type*) [MulOneClass M] : M →* M 
goal: M →* M

full_name: AddMonoidHom.id_apply
code: /-- The identity map from a monoid to itself. -/
@[to_additive (attr := simps) "The identity map from an additive monoid to itself."]
def MonoidHom.id (M : Type*) [MulOneClass M] : M →* M 
goal: (AddMonoidHom.id M) x = x

full_name: MonoidHom.id_apply
code: /-- The identity map from a monoid to itself. -/
@[to_additive (attr := simps) "The identity map from an additive monoid to itself."]
def MonoidHom.id (M : Type*) [MulOneClass M] : M →* M 
goal: (MonoidHom.id M) x = x

full_name: OneHom.comp
code: /-- Composition of `OneHom`s as a `OneHom`. -/
@[to_additive "Composition of `ZeroHom`s as a `ZeroHom`."]
def OneHom.comp [One M] [One N] [One P] (hnp : OneHom N P) (hmn : OneHom M N) : OneHom M P 
goal: OneHom M P

full_name: ZeroHom.comp
code: /-- Composition of `OneHom`s as a `OneHom`. -/
@[to_additive "Composition of `ZeroHom`s as a `ZeroHom`."]
def OneHom.comp [One M] [One N] [One P] (hnp : OneHom N P) (hmn : OneHom M N) : OneHom M P 
goal: ZeroHom M P

full_name: AddHom.comp
code: /-- Composition of `MulHom`s as a `MulHom`. -/
@[to_additive "Composition of `AddHom`s as an `AddHom`."]
def MulHom.comp [Mul M] [Mul N] [Mul P] (hnp : N →ₙ* P) (hmn : M →ₙ* N) : M →ₙ* P 
goal: AddHom M P

full_name: MulHom.comp
code: /-- Composition of `MulHom`s as a `MulHom`. -/
@[to_additive "Composition of `AddHom`s as an `AddHom`."]
def MulHom.comp [Mul M] [Mul N] [Mul P] (hnp : N →ₙ* P) (hmn : M →ₙ* N) : M →ₙ* P 
goal: M →ₙ* P

full_name: MonoidHom.comp
code: /-- Composition of monoid morphisms as a monoid morphism. -/
@[to_additive "Composition of additive monoid morphisms as an additive monoid morphism."]
def MonoidHom.comp [MulOneClass M] [MulOneClass N] [MulOneClass P] (hnp : N →* P) (hmn : M →* N) :
    M →* P 
goal: M →* P

full_name: AddMonoidHom.comp
code: /-- Composition of monoid morphisms as a monoid morphism. -/
@[to_additive "Composition of additive monoid morphisms as an additive monoid morphism."]
def MonoidHom.comp [MulOneClass M] [MulOneClass N] [MulOneClass P] (hnp : N →* P) (hmn : M →* N) :
    M →* P 
goal: M →+ P

full_name: OneHom.coe_comp
code: @[to_additive (attr := simp)]
theorem OneHom.coe_comp [One M] [One N] [One P] (g : OneHom N P) (f : OneHom M N) :
    ↑(g.comp f) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: ZeroHom.coe_comp
code: @[to_additive (attr := simp)]
theorem OneHom.coe_comp [One M] [One N] [One P] (g : OneHom N P) (f : OneHom M N) :
    ↑(g.comp f) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: MulHom.coe_comp
code: @[to_additive (attr := simp)]
theorem MulHom.coe_comp [Mul M] [Mul N] [Mul P] (g : N →ₙ* P) (f : M →ₙ* N) :
    ↑(g.comp f) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: AddHom.coe_comp
code: @[to_additive (attr := simp)]
theorem MulHom.coe_comp [Mul M] [Mul N] [Mul P] (g : N →ₙ* P) (f : M →ₙ* N) :
    ↑(g.comp f) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: MonoidHom.coe_comp
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_comp [MulOneClass M] [MulOneClass N] [MulOneClass P]
    (g : N →* P) (f : M →* N) : ↑(g.comp f) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: AddMonoidHom.coe_comp
code: @[to_additive (attr := simp)]
theorem MonoidHom.coe_comp [MulOneClass M] [MulOneClass N] [MulOneClass P]
    (g : N →* P) (f : M →* N) : ↑(g.comp f) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: OneHom.comp_apply
code: @[to_additive]
theorem OneHom.comp_apply [One M] [One N] [One P] (g : OneHom N P) (f : OneHom M N) (x : M) :
    g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: ZeroHom.comp_apply
code: @[to_additive]
theorem OneHom.comp_apply [One M] [One N] [One P] (g : OneHom N P) (f : OneHom M N) (x : M) :
    g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: AddHom.comp_apply
code: @[to_additive]
theorem MulHom.comp_apply [Mul M] [Mul N] [Mul P] (g : N →ₙ* P) (f : M →ₙ* N) (x : M) :
    g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: MulHom.comp_apply
code: @[to_additive]
theorem MulHom.comp_apply [Mul M] [Mul N] [Mul P] (g : N →ₙ* P) (f : M →ₙ* N) (x : M) :
    g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: MonoidHom.comp_apply
code: @[to_additive]
theorem MonoidHom.comp_apply [MulOneClass M] [MulOneClass N] [MulOneClass P]
    (g : N →* P) (f : M →* N) (x : M) : g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: AddMonoidHom.comp_apply
code: @[to_additive]
theorem MonoidHom.comp_apply [MulOneClass M] [MulOneClass N] [MulOneClass P]
    (g : N →* P) (f : M →* N) (x : M) : g.comp f x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: OneHom.comp_assoc
code: /-- Composition of monoid homomorphisms is associative. -/
@[to_additive "Composition of additive monoid homomorphisms is associative."]
theorem OneHom.comp_assoc {Q : Type*} [One M] [One N] [One P] [One Q]
    (f : OneHom M N) (g : OneHom N P) (h : OneHom P Q) :
    (h.comp g).comp f = h.comp (g.comp f) 
goal: (h.comp g).comp f = h.comp (g.comp f)

full_name: ZeroHom.comp_assoc
code: /-- Composition of monoid homomorphisms is associative. -/
@[to_additive "Composition of additive monoid homomorphisms is associative."]
theorem OneHom.comp_assoc {Q : Type*} [One M] [One N] [One P] [One Q]
    (f : OneHom M N) (g : OneHom N P) (h : OneHom P Q) :
    (h.comp g).comp f = h.comp (g.comp f) 
goal: (h.comp g).comp f = h.comp (g.comp f)

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

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

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

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

full_name: OneHom.cancel_right
code: @[to_additive]
theorem OneHom.cancel_right [One M] [One N] [One P] {g₁ g₂ : OneHom N P} {f : OneHom M N}
    (hf : Function.Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: ZeroHom.cancel_right
code: @[to_additive]
theorem OneHom.cancel_right [One M] [One N] [One P] {g₁ g₂ : OneHom N P} {f : OneHom M N}
    (hf : Function.Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: AddHom.cancel_right
code: @[to_additive]
theorem MulHom.cancel_right [Mul M] [Mul N] [Mul P] {g₁ g₂ : N →ₙ* P} {f : M →ₙ* N}
    (hf : Function.Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: MulHom.cancel_right
code: @[to_additive]
theorem MulHom.cancel_right [Mul M] [Mul N] [Mul P] {g₁ g₂ : N →ₙ* P} {f : M →ₙ* N}
    (hf : Function.Surjective f) : g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: MonoidHom.cancel_right
code: @[to_additive]
theorem MonoidHom.cancel_right [MulOneClass M] [MulOneClass N] [MulOneClass P]
    {g₁ g₂ : N →* P} {f : M →* N} (hf : Function.Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: AddMonoidHom.cancel_right
code: @[to_additive]
theorem MonoidHom.cancel_right [MulOneClass M] [MulOneClass N] [MulOneClass P]
    {g₁ g₂ : N →* P} {f : M →* N} (hf : Function.Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: ZeroHom.cancel_left
code: @[to_additive]
theorem OneHom.cancel_left [One M] [One N] [One P] {g : OneHom N P} {f₁ f₂ : OneHom M N}
    (hg : Function.Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: OneHom.cancel_left
code: @[to_additive]
theorem OneHom.cancel_left [One M] [One N] [One P] {g : OneHom N P} {f₁ f₂ : OneHom M N}
    (hg : Function.Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: AddHom.cancel_left
code: @[to_additive]
theorem MulHom.cancel_left [Mul M] [Mul N] [Mul P] {g : N →ₙ* P} {f₁ f₂ : M →ₙ* N}
    (hg : Function.Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: MulHom.cancel_left
code: @[to_additive]
theorem MulHom.cancel_left [Mul M] [Mul N] [Mul P] {g : N →ₙ* P} {f₁ f₂ : M →ₙ* N}
    (hg : Function.Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: MonoidHom.cancel_left
code: @[to_additive]
theorem MonoidHom.cancel_left [MulOneClass M] [MulOneClass N] [MulOneClass P]
    {g : N →* P} {f₁ f₂ : M →* N} (hg : Function.Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: AddMonoidHom.cancel_left
code: @[to_additive]
theorem MonoidHom.cancel_left [MulOneClass M] [MulOneClass N] [MulOneClass P]
    {g : N →* P} {f₁ f₂ : M →* N} (hg : Function.Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: MonoidHom.toOneHom_injective
code: @[to_additive]
theorem MonoidHom.toOneHom_injective [MulOneClass M] [MulOneClass N] :
    Function.Injective (MonoidHom.toOneHom : (M →* N) → OneHom M N) 
goal: Function.Injective MonoidHom.toOneHom

full_name: AddMonoidHom.toZeroHom_injective
code: @[to_additive]
theorem MonoidHom.toOneHom_injective [MulOneClass M] [MulOneClass N] :
    Function.Injective (MonoidHom.toOneHom : (M →* N) → OneHom M N) 
goal: Function.Injective AddMonoidHom.toZeroHom

full_name: AddMonoidHom.toAddHom_injective
code: @[to_additive]
theorem MonoidHom.toMulHom_injective [MulOneClass M] [MulOneClass N] :
    Function.Injective (MonoidHom.toMulHom : (M →* N) → M →ₙ* N) 
goal: Function.Injective AddMonoidHom.toAddHom

full_name: MonoidHom.toMulHom_injective
code: @[to_additive]
theorem MonoidHom.toMulHom_injective [MulOneClass M] [MulOneClass N] :
    Function.Injective (MonoidHom.toMulHom : (M →* N) → M →ₙ* N) 
goal: Function.Injective MonoidHom.toMulHom

full_name: ZeroHom.comp_id
code: @[to_additive (attr := simp)]
theorem OneHom.comp_id [One M] [One N] (f : OneHom M N) : f.comp (OneHom.id M) = f 
goal: f.comp (ZeroHom.id M) = f

full_name: OneHom.comp_id
code: @[to_additive (attr := simp)]
theorem OneHom.comp_id [One M] [One N] (f : OneHom M N) : f.comp (OneHom.id M) = f 
goal: f.comp (OneHom.id M) = f

full_name: AddHom.comp_id
code: @[to_additive (attr := simp)]
theorem MulHom.comp_id [Mul M] [Mul N] (f : M →ₙ* N) : f.comp (MulHom.id M) = f 
goal: f.comp (AddHom.id M) = f

full_name: MulHom.comp_id
code: @[to_additive (attr := simp)]
theorem MulHom.comp_id [Mul M] [Mul N] (f : M →ₙ* N) : f.comp (MulHom.id M) = f 
goal: f.comp (MulHom.id M) = f

full_name: AddMonoidHom.comp_id
code: @[to_additive (attr := simp)]
theorem MonoidHom.comp_id [MulOneClass M] [MulOneClass N] (f : M →* N) :
    f.comp (MonoidHom.id M) = f 
goal: f.comp (AddMonoidHom.id M) = f

full_name: MonoidHom.comp_id
code: @[to_additive (attr := simp)]
theorem MonoidHom.comp_id [MulOneClass M] [MulOneClass N] (f : M →* N) :
    f.comp (MonoidHom.id M) = f 
goal: f.comp (MonoidHom.id M) = f

full_name: OneHom.id_comp
code: @[to_additive (attr := simp)]
theorem OneHom.id_comp [One M] [One N] (f : OneHom M N) : (OneHom.id N).comp f = f 
goal: (OneHom.id N).comp f = f

full_name: ZeroHom.id_comp
code: @[to_additive (attr := simp)]
theorem OneHom.id_comp [One M] [One N] (f : OneHom M N) : (OneHom.id N).comp f = f 
goal: (ZeroHom.id N).comp f = f

full_name: AddHom.id_comp
code: @[to_additive (attr := simp)]
theorem MulHom.id_comp [Mul M] [Mul N] (f : M →ₙ* N) : (MulHom.id N).comp f = f 
goal: (AddHom.id N).comp f = f

full_name: MulHom.id_comp
code: @[to_additive (attr := simp)]
theorem MulHom.id_comp [Mul M] [Mul N] (f : M →ₙ* N) : (MulHom.id N).comp f = f 
goal: (MulHom.id N).comp f = f

full_name: MonoidHom.id_comp
code: @[to_additive (attr := simp)]
theorem MonoidHom.id_comp [MulOneClass M] [MulOneClass N] (f : M →* N) :
    (MonoidHom.id N).comp f = f 
goal: (MonoidHom.id N).comp f = f

full_name: AddMonoidHom.id_comp
code: @[to_additive (attr := simp)]
theorem MonoidHom.id_comp [MulOneClass M] [MulOneClass N] (f : M →* N) :
    (MonoidHom.id N).comp f = f 
goal: (AddMonoidHom.id N).comp f = f

full_name: MonoidHom.map_pow
code: @[to_additive]
protected theorem MonoidHom.map_pow [Monoid M] [Monoid N] (f : M →* N) (a : M) (n : ℕ) :
    f (a ^ n) = f a ^ n 
goal: f (a ^ n) = f a ^ n

full_name: AddMonoidHom.map_nsmul
code: @[to_additive]
protected theorem MonoidHom.map_pow [Monoid M] [Monoid N] (f : M →* N) (a : M) (n : ℕ) :
    f (a ^ n) = f a ^ n 
goal: f (n • a) = n • f a

full_name: AddMonoidHom.map_zsmul'
code: @[to_additive]
protected theorem MonoidHom.map_zpow' [DivInvMonoid M] [DivInvMonoid N] (f : M →* N)
    (hf : ∀ x, f x⁻¹ = (f x)⁻¹) (a : M) (n : ℤ) :
    f (a ^ n) = f a ^ n 
goal: f (n • a) = n • f a

full_name: MonoidHom.map_zpow'
code: @[to_additive]
protected theorem MonoidHom.map_zpow' [DivInvMonoid M] [DivInvMonoid N] (f : M →* N)
    (hf : ∀ x, f x⁻¹ = (f x)⁻¹) (a : M) (n : ℤ) :
    f (a ^ n) = f a ^ n 
goal: f (a ^ n) = f a ^ n

full_name: Monoid.End
code: /-- The monoid of endomorphisms. -/
protected def End 
goal: Type u_4

full_name: Monoid.End.instFunLike
code: instance instFunLike : FunLike (Monoid.End M) M M 
goal: FunLike (Monoid.End M) M M

full_name: Monoid.End.instMonoidHomClass
code: instance instMonoidHomClass : MonoidHomClass (Monoid.End M) M M 
goal: MonoidHomClass (Monoid.End M) M M

full_name: Monoid.End.instOne
code: instance instOne : One (Monoid.End M) 
goal: One (Monoid.End M)

full_name: Monoid.End.instMul
code: instance instMul : Mul (Monoid.End M) 
goal: Mul (Monoid.End M)

full_name: Monoid.End.inst
code: instance : Monoid (Monoid.End M) 
goal: Monoid (Monoid.End M)

full_name: Monoid.End.instInhabited
code: instance : Inhabited (Monoid.End M) 
goal: Inhabited (Monoid.End M)

full_name: Monoid.End.coe_pow
code: @[simp, norm_cast] lemma coe_pow (f : Monoid.End M) (n : ℕ) : (↑(f ^ n) : M → M) = f^[n] 
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: Monoid.coe_one
code: @[simp]
theorem coe_one : ((1 : Monoid.End M) : M → M) = id 
goal: ⇑1 = id

full_name: Monoid.coe_mul
code: @[simp]
theorem coe_mul (f g) : ((f * g : Monoid.End M) : M → M) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: AddMonoid.End
code: /-- The monoid of endomorphisms. -/
protected def End 
goal: Type u_10

full_name: AddMonoid.End.instFunLike
code: instance instFunLike : FunLike (AddMonoid.End A) A A 
goal: FunLike (AddMonoid.End A) A A

full_name: AddMonoid.End.instAddMonoidHomClass
code: instance instAddMonoidHomClass : AddMonoidHomClass (AddMonoid.End A) A A 
goal: AddMonoidHomClass (AddMonoid.End A) A A

full_name: AddMonoid.End.instOne
code: instance instOne : One (AddMonoid.End A) 
goal: One (AddMonoid.End A)

full_name: AddMonoid.End.instMul
code: instance instMul : Mul (AddMonoid.End A) 
goal: Mul (AddMonoid.End A)

full_name: AddMonoid.End.coe_one
code: @[simp, norm_cast] lemma coe_one : ((1 : AddMonoid.End A) : A → A) = id 
goal: ⇑1 = id

full_name: AddMonoid.End.coe_mul
code: @[simp, norm_cast] lemma coe_mul (f g : AddMonoid.End A) : (f * g : A → A) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: AddMonoid.End.monoid
code: instance monoid : Monoid (AddMonoid.End A) 
goal: Monoid (AddMonoid.End A)

full_name: AddMonoid.End.coe_pow
code: @[simp, norm_cast] lemma coe_pow (f : AddMonoid.End A) (n : ℕ) : (↑(f ^ n) : A → A) = f^[n] 
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: AddMonoid.End.instInhabited
code: instance : Inhabited (AddMonoid.End A) 
goal: Inhabited (AddMonoid.End A)

full_name: instOneOneHom
code: /-- `1` is the homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the homomorphism sending all elements to `0`."]
instance [One M] [One N] : One (OneHom M N) 
goal: One (OneHom M N)

full_name: instZeroZeroHom
code: /-- `1` is the homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the homomorphism sending all elements to `0`."]
instance [One M] [One N] : One (OneHom M N) 
goal: Zero (ZeroHom M N)

full_name: instZeroAddHom
code: /-- `1` is the multiplicative homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the additive homomorphism sending all elements to `0`"]
instance [Mul M] [MulOneClass N] : One (M →ₙ* N) 
goal: Zero (AddHom M N)

full_name: instOneMulHom
code: /-- `1` is the multiplicative homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the additive homomorphism sending all elements to `0`"]
instance [Mul M] [MulOneClass N] : One (M →ₙ* N) 
goal: One (M →ₙ* N)

full_name: instZeroAddMonoidHom
code: /-- `1` is the monoid homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the additive monoid homomorphism sending all elements to `0`."]
instance [MulOneClass M] [MulOneClass N] : One (M →* N) 
goal: Zero (M →+ N)

full_name: instOneMonoidHom
code: /-- `1` is the monoid homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the additive monoid homomorphism sending all elements to `0`."]
instance [MulOneClass M] [MulOneClass N] : One (M →* N) 
goal: One (M →* N)

full_name: ZeroHom.zero_apply
code: @[to_additive (attr := simp)]
theorem OneHom.one_apply [One M] [One N] (x : M) : (1 : OneHom M N) x = 1 
goal: 0 x = 0

full_name: OneHom.one_apply
code: @[to_additive (attr := simp)]
theorem OneHom.one_apply [One M] [One N] (x : M) : (1 : OneHom M N) x = 1 
goal: 1 x = 1

full_name: MonoidHom.one_apply
code: @[to_additive (attr := simp)]
theorem MonoidHom.one_apply [MulOneClass M] [MulOneClass N] (x : M) : (1 : M →* N) x = 1 
goal: 1 x = 1

full_name: AddMonoidHom.zero_apply
code: @[to_additive (attr := simp)]
theorem MonoidHom.one_apply [MulOneClass M] [MulOneClass N] (x : M) : (1 : M →* N) x = 1 
goal: 0 x = 0

full_name: OneHom.one_comp
code: @[to_additive (attr := simp)]
theorem OneHom.one_comp [One M] [One N] [One P] (f : OneHom M N) :
    (1 : OneHom N P).comp f = 1 
goal: OneHom.comp 1 f = 1

full_name: ZeroHom.zero_comp
code: @[to_additive (attr := simp)]
theorem OneHom.one_comp [One M] [One N] [One P] (f : OneHom M N) :
    (1 : OneHom N P).comp f = 1 
goal: ZeroHom.comp 0 f = 0

full_name: OneHom.comp_one
code: @[to_additive (attr := simp)]
theorem OneHom.comp_one [One M] [One N] [One P] (f : OneHom N P) : f.comp (1 : OneHom M N) = 1 
goal: f.comp 1 = 1

full_name: ZeroHom.comp_zero
code: @[to_additive (attr := simp)]
theorem OneHom.comp_one [One M] [One N] [One P] (f : OneHom N P) : f.comp (1 : OneHom M N) = 1 
goal: f.comp 0 = 0

full_name: instInhabitedZeroHom
code: @[to_additive]
instance [One M] [One N] : Inhabited (OneHom M N) 
goal: Inhabited (ZeroHom M N)

full_name: instInhabitedOneHom
code: @[to_additive]
instance [One M] [One N] : Inhabited (OneHom M N) 
goal: Inhabited (OneHom M N)

full_name: instInhabitedMulHom
code: @[to_additive]
instance [Mul M] [MulOneClass N] : Inhabited (M →ₙ* N) 
goal: Inhabited (M →ₙ* N)

full_name: instInhabitedAddHom
code: @[to_additive]
instance [Mul M] [MulOneClass N] : Inhabited (M →ₙ* N) 
goal: Inhabited (AddHom M N)

full_name: instInhabitedAddMonoidHom
code: @[to_additive]
instance [MulOneClass M] [MulOneClass N] : Inhabited (M →* N) 
goal: Inhabited (M →+ N)

full_name: instInhabitedMonoidHom
code: @[to_additive]
instance [MulOneClass M] [MulOneClass N] : Inhabited (M →* N) 
goal: Inhabited (M →* N)

full_name: MonoidHom.one_comp
code: @[to_additive (attr := simp)]
theorem one_comp [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : M →* N) :
    (1 : N →* P).comp f = 1 
goal: MonoidHom.comp 1 f = 1

full_name: AddMonoidHom.zero_comp
code: @[to_additive (attr := simp)]
theorem one_comp [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : M →* N) :
    (1 : N →* P).comp f = 1 
goal: AddMonoidHom.comp 0 f = 0

full_name: AddMonoidHom.comp_zero
code: @[to_additive (attr := simp)]
theorem comp_one [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : N →* P) :
    f.comp (1 : M →* N) = 1 
goal: f.comp 0 = 0

full_name: MonoidHom.comp_one
code: @[to_additive (attr := simp)]
theorem comp_one [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : N →* P) :
    f.comp (1 : M →* N) = 1 
goal: f.comp 1 = 1

full_name: AddMonoidHom.map_neg
code: /-- Group homomorphisms preserve inverse. -/
@[to_additive "Additive group homomorphisms preserve negation."]
protected theorem map_inv [Group α] [DivisionMonoid β] (f : α →* β) (a : α) : f a⁻¹ = (f a)⁻¹ 
goal: f (-a) = -f a

full_name: MonoidHom.map_inv
code: /-- Group homomorphisms preserve inverse. -/
@[to_additive "Additive group homomorphisms preserve negation."]
protected theorem map_inv [Group α] [DivisionMonoid β] (f : α →* β) (a : α) : f a⁻¹ = (f a)⁻¹ 
goal: f a⁻¹ = (f a)⁻¹

full_name: AddMonoidHom.map_zsmul
code: /-- Group homomorphisms preserve integer power. -/
@[to_additive "Additive group homomorphisms preserve integer scaling."]
protected theorem map_zpow [Group α] [DivisionMonoid β] (f : α →* β) (g : α) (n : ℤ) :
    f (g ^ n) = f g ^ n 
goal: f (n • g) = n • f g

full_name: MonoidHom.map_zpow
code: /-- Group homomorphisms preserve integer power. -/
@[to_additive "Additive group homomorphisms preserve integer scaling."]
protected theorem map_zpow [Group α] [DivisionMonoid β] (f : α →* β) (g : α) (n : ℤ) :
    f (g ^ n) = f g ^ n 
goal: f (g ^ n) = f g ^ n

full_name: AddMonoidHom.map_sub
code: /-- Group homomorphisms preserve division. -/
@[to_additive "Additive group homomorphisms preserve subtraction."]
protected theorem map_div [Group α] [DivisionMonoid β] (f : α →* β) (g h : α) :
    f (g / h) = f g / f h 
goal: f (g - h) = f g - f h

full_name: MonoidHom.map_div
code: /-- Group homomorphisms preserve division. -/
@[to_additive "Additive group homomorphisms preserve subtraction."]
protected theorem map_div [Group α] [DivisionMonoid β] (f : α →* β) (g h : α) :
    f (g / h) = f g / f h 
goal: f (g / h) = f g / f h

full_name: AddMonoidHom.map_add_neg
code: /-- Group homomorphisms preserve division. -/
@[to_additive "Additive group homomorphisms preserve subtraction."]
protected theorem map_mul_inv [Group α] [DivisionMonoid β] (f : α →* β) (g h : α) :
    f (g * h⁻¹) = f g * (f h)⁻¹ 
goal: f (g + -h) = f g + -f h

full_name: MonoidHom.map_mul_inv
code: /-- Group homomorphisms preserve division. -/
@[to_additive "Additive group homomorphisms preserve subtraction."]
protected theorem map_mul_inv [Group α] [DivisionMonoid β] (f : α →* β) (g h : α) :
    f (g * h⁻¹) = f g * (f h)⁻¹ 
goal: f (g * h⁻¹) = f g * (f h)⁻¹