File: Mathlib/Deprecated/Group.lean

full_name: IsAddHom.map_add
code: /-- Predicate for maps which preserve an addition. -/
structure IsAddHom {α β : Type*} [Add α] [Add β] (f : α → β) : Prop where
  /-- The proposition that `f` preserves addition. -/
  map_add : ∀ x y, f (x + y) = f x + f y
goal: f (x + y) = f x + f y

full_name: IsAddHom
code: /-- Predicate for maps which preserve an addition. -/
structure IsAddHom {α β : Type*} [Add α] [Add β] (f : α → β) : Prop where
  /-- The proposition that `f` preserves addition. -/
  map_add : ∀ x y, f (x + y) = f x + f y
goal: Prop

full_name: IsMulHom
code: /-- Predicate for maps which preserve a multiplication. -/
@[to_additive]
structure IsMulHom {α β : Type*} [Mul α] [Mul β] (f : α → β) : Prop where
  /-- The proposition that `f` preserves multiplication. -/
  map_mul : ∀ x y, f (x * y) = f x * f y
goal: Prop

full_name: IsMulHom.map_mul
code: /-- Predicate for maps which preserve a multiplication. -/
@[to_additive]
structure IsMulHom {α β : Type*} [Mul α] [Mul β] (f : α → β) : Prop where
  /-- The proposition that `f` preserves multiplication. -/
  map_mul : ∀ x y, f (x * y) = f x * f y
goal: f (x * y) = f x * f y

full_name: IsAddHom.id
code: /-- The identity map preserves multiplication. -/
@[to_additive "The identity map preserves addition"]
theorem id : IsMulHom (id : α → α) 
goal: IsAddHom id

full_name: IsMulHom.id
code: /-- The identity map preserves multiplication. -/
@[to_additive "The identity map preserves addition"]
theorem id : IsMulHom (id : α → α) 
goal: IsMulHom id

full_name: IsMulHom.comp
code: /-- The composition of maps which preserve multiplication, also preserves multiplication. -/
@[to_additive "The composition of addition preserving maps also preserves addition"]
theorem comp {f : α → β} {g : β → γ} (hf : IsMulHom f) (hg : IsMulHom g) : IsMulHom (g ∘ f) 
goal: IsMulHom (g ∘ f)

full_name: IsAddHom.comp
code: /-- The composition of maps which preserve multiplication, also preserves multiplication. -/
@[to_additive "The composition of addition preserving maps also preserves addition"]
theorem comp {f : α → β} {g : β → γ} (hf : IsMulHom f) (hg : IsMulHom g) : IsMulHom (g ∘ f) 
goal: IsAddHom (g ∘ f)

full_name: IsAddHom.add
code: /-- A product of maps which preserve multiplication,
preserves multiplication when the target is commutative. -/
@[to_additive
      "A sum of maps which preserves addition, preserves addition when the target
      is commutative."]
theorem mul {α β} [Semigroup α] [CommSemigroup β] {f g : α → β} (hf : IsMulHom f)
    (hg : IsMulHom g) : IsMulHom fun a => f a * g a 
goal: IsAddHom fun a => f a + g a

full_name: IsMulHom.mul
code: /-- A product of maps which preserve multiplication,
preserves multiplication when the target is commutative. -/
@[to_additive
      "A sum of maps which preserves addition, preserves addition when the target
      is commutative."]
theorem mul {α β} [Semigroup α] [CommSemigroup β] {f g : α → β} (hf : IsMulHom f)
    (hg : IsMulHom g) : IsMulHom fun a => f a * g a 
goal: IsMulHom fun a => f a * g a

full_name: IsMulHom.inv
code: /-- The inverse of a map which preserves multiplication,
preserves multiplication when the target is commutative. -/
@[to_additive
      "The negation of a map which preserves addition, preserves addition when
      the target is commutative."]
theorem inv {α β} [Mul α] [CommGroup β] {f : α → β} (hf : IsMulHom f) : IsMulHom fun a => (f a)⁻¹ 
goal: IsMulHom fun a => (f a)⁻¹

full_name: IsAddHom.neg
code: /-- The inverse of a map which preserves multiplication,
preserves multiplication when the target is commutative. -/
@[to_additive
      "The negation of a map which preserves addition, preserves addition when
      the target is commutative."]
theorem inv {α β} [Mul α] [CommGroup β] {f : α → β} (hf : IsMulHom f) : IsMulHom fun a => (f a)⁻¹ 
goal: IsAddHom fun a => -f a

full_name: IsAddMonoidHom.map_zero
code: /-- Predicate for additive monoid homomorphisms
(deprecated -- use the bundled `MonoidHom` version). -/
structure IsAddMonoidHom [AddZeroClass α] [AddZeroClass β] (f : α → β) extends IsAddHom f :
  Prop where
  /-- The proposition that `f` preserves the additive identity. -/
  map_zero : f 0 = 0
goal: f 0 = 0

full_name: IsAddMonoidHom
code: /-- Predicate for additive monoid homomorphisms
(deprecated -- use the bundled `MonoidHom` version). -/
structure IsAddMonoidHom [AddZeroClass α] [AddZeroClass β] (f : α → β) extends IsAddHom f :
  Prop where
  /-- The proposition that `f` preserves the additive identity. -/
  map_zero : f 0 = 0
goal: Prop

full_name: IsMonoidHom.map_one
code: /-- Predicate for monoid homomorphisms (deprecated -- use the bundled `MonoidHom` version). -/
@[to_additive]
structure IsMonoidHom [MulOneClass α] [MulOneClass β] (f : α → β) extends IsMulHom f : Prop where
  /-- The proposition that `f` preserves the multiplicative identity. -/
  map_one : f 1 = 1
goal: f 1 = 1

full_name: IsMonoidHom
code: /-- Predicate for monoid homomorphisms (deprecated -- use the bundled `MonoidHom` version). -/
@[to_additive]
structure IsMonoidHom [MulOneClass α] [MulOneClass β] (f : α → β) extends IsMulHom f : Prop where
  /-- The proposition that `f` preserves the multiplicative identity. -/
  map_one : f 1 = 1
goal: Prop

full_name: MonoidHom.of
code: /-- Interpret a map `f : M → N` as a homomorphism `M →* N`. -/
@[to_additive "Interpret a map `f : M → N` as a homomorphism `M →+ N`."]
def of {f : M → N} (h : IsMonoidHom f) : M →* N 
goal: M →* N

full_name: AddMonoidHom.of
code: /-- Interpret a map `f : M → N` as a homomorphism `M →* N`. -/
@[to_additive "Interpret a map `f : M → N` as a homomorphism `M →+ N`."]
def of {f : M → N} (h : IsMonoidHom f) : M →* N 
goal: M →+ N

full_name: AddMonoidHom.coe_of
code: @[to_additive (attr := simp)]
theorem coe_of {f : M → N} (hf : IsMonoidHom f) : ⇑(MonoidHom.of hf) = f 
goal: ⇑(AddMonoidHom.of hf) = f

full_name: MonoidHom.coe_of
code: @[to_additive (attr := simp)]
theorem coe_of {f : M → N} (hf : IsMonoidHom f) : ⇑(MonoidHom.of hf) = f 
goal: ⇑(MonoidHom.of hf) = f

full_name: AddMonoidHom.isAddMonoidHom_coe
code: @[to_additive]
theorem isMonoidHom_coe (f : M →* N) : IsMonoidHom (f : M → N) 
goal: IsAddMonoidHom ⇑f

full_name: MonoidHom.isMonoidHom_coe
code: @[to_additive]
theorem isMonoidHom_coe (f : M →* N) : IsMonoidHom (f : M → N) 
goal: IsMonoidHom ⇑f

full_name: AddEquiv.isAddHom
code: /-- A multiplicative isomorphism preserves multiplication (deprecated). -/
@[to_additive "An additive isomorphism preserves addition (deprecated)."]
theorem isMulHom (h : M ≃* N) : IsMulHom h 
goal: IsAddHom ⇑h

full_name: MulEquiv.isMulHom
code: /-- A multiplicative isomorphism preserves multiplication (deprecated). -/
@[to_additive "An additive isomorphism preserves addition (deprecated)."]
theorem isMulHom (h : M ≃* N) : IsMulHom h 
goal: IsMulHom ⇑h

full_name: MulEquiv.isMonoidHom
code: /-- A multiplicative bijection between two monoids is a monoid hom
  (deprecated -- use `MulEquiv.toMonoidHom`). -/
@[to_additive
      "An additive bijection between two additive monoids is an additive
      monoid hom (deprecated). "]
theorem isMonoidHom (h : M ≃* N) : IsMonoidHom h 
goal: IsMonoidHom ⇑h

full_name: AddEquiv.isAddMonoidHom
code: /-- A multiplicative bijection between two monoids is a monoid hom
  (deprecated -- use `MulEquiv.toMonoidHom`). -/
@[to_additive
      "An additive bijection between two additive monoids is an additive
      monoid hom (deprecated). "]
theorem isMonoidHom (h : M ≃* N) : IsMonoidHom h 
goal: IsAddMonoidHom ⇑h

full_name: IsMonoidHom.map_mul'
code: /-- A monoid homomorphism preserves multiplication. -/
@[to_additive "An additive monoid homomorphism preserves addition."]
theorem map_mul' (x y) : f (x * y) = f x * f y 
goal: f (x * y) = f x * f y

full_name: IsAddMonoidHom.map_add'
code: /-- A monoid homomorphism preserves multiplication. -/
@[to_additive "An additive monoid homomorphism preserves addition."]
theorem map_mul' (x y) : f (x * y) = f x * f y 
goal: f (x + y) = f x + f y

full_name: IsAddMonoidHom.neg
code: /-- The inverse of a map which preserves multiplication,
preserves multiplication when the target is commutative. -/
@[to_additive
      "The negation of a map which preserves addition, preserves addition
      when the target is commutative."]
theorem inv {α β} [MulOneClass α] [CommGroup β] {f : α → β} (hf : IsMonoidHom f) :
    IsMonoidHom fun a => (f a)⁻¹ 
goal: IsAddMonoidHom fun a => -f a

full_name: IsMonoidHom.inv
code: /-- The inverse of a map which preserves multiplication,
preserves multiplication when the target is commutative. -/
@[to_additive
      "The negation of a map which preserves addition, preserves addition
      when the target is commutative."]
theorem inv {α β} [MulOneClass α] [CommGroup β] {f : α → β} (hf : IsMonoidHom f) :
    IsMonoidHom fun a => (f a)⁻¹ 
goal: IsMonoidHom fun a => (f a)⁻¹

full_name: IsMulHom.to_isMonoidHom
code: /-- A map to a group preserving multiplication is a monoid homomorphism. -/
@[to_additive "A map to an additive group preserving addition is an additive monoid
homomorphism."]
theorem IsMulHom.to_isMonoidHom [MulOneClass α] [Group β] {f : α → β} (hf : IsMulHom f) :
    IsMonoidHom f 
goal: IsMonoidHom f

full_name: IsAddHom.to_isAddMonoidHom
code: /-- A map to a group preserving multiplication is a monoid homomorphism. -/
@[to_additive "A map to an additive group preserving addition is an additive monoid
homomorphism."]
theorem IsMulHom.to_isMonoidHom [MulOneClass α] [Group β] {f : α → β} (hf : IsMulHom f) :
    IsMonoidHom f 
goal: IsAddMonoidHom f

full_name: IsMonoidHom.id
code: /-- The identity map is a monoid homomorphism. -/
@[to_additive "The identity map is an additive monoid homomorphism."]
theorem id : IsMonoidHom (@id α) 
goal: IsMonoidHom id

full_name: IsAddMonoidHom.id
code: /-- The identity map is a monoid homomorphism. -/
@[to_additive "The identity map is an additive monoid homomorphism."]
theorem id : IsMonoidHom (@id α) 
goal: IsAddMonoidHom id

full_name: IsAddMonoidHom.comp
code: /-- The composite of two monoid homomorphisms is a monoid homomorphism. -/
@[to_additive
      "The composite of two additive monoid homomorphisms is an additive monoid
      homomorphism."]
theorem comp (hf : IsMonoidHom f) {γ} [MulOneClass γ] {g : β → γ} (hg : IsMonoidHom g) :
    IsMonoidHom (g ∘ f) 
goal: IsAddMonoidHom (g ∘ f)

full_name: IsMonoidHom.comp
code: /-- The composite of two monoid homomorphisms is a monoid homomorphism. -/
@[to_additive
      "The composite of two additive monoid homomorphisms is an additive monoid
      homomorphism."]
theorem comp (hf : IsMonoidHom f) {γ} [MulOneClass γ] {g : β → γ} (hg : IsMonoidHom g) :
    IsMonoidHom (g ∘ f) 
goal: IsMonoidHom (g ∘ f)

full_name: IsAddMonoidHom.isAddMonoidHom_mul_left
code: /-- Left multiplication in a ring is an additive monoid morphism. -/
theorem isAddMonoidHom_mul_left {γ : Type*} [NonUnitalNonAssocSemiring γ] (x : γ) :
    IsAddMonoidHom fun y : γ => x * y 
goal: IsAddMonoidHom fun y => x * y

full_name: IsAddMonoidHom.isAddMonoidHom_mul_right
code: /-- Right multiplication in a ring is an additive monoid morphism. -/
theorem isAddMonoidHom_mul_right {γ : Type*} [NonUnitalNonAssocSemiring γ] (x : γ) :
    IsAddMonoidHom fun y : γ => y * x 
goal: IsAddMonoidHom fun y => y * x

full_name: IsAddGroupHom
code: /-- Predicate for additive group homomorphism (deprecated -- use bundled `MonoidHom`). -/
structure IsAddGroupHom [AddGroup α] [AddGroup β] (f : α → β) extends IsAddHom f : Prop
goal: Prop

full_name: IsGroupHom
code: /-- Predicate for group homomorphisms (deprecated -- use bundled `MonoidHom`). -/
@[to_additive]
structure IsGroupHom [Group α] [Group β] (f : α → β) extends IsMulHom f : Prop
goal: Prop

full_name: AddMonoidHom.isAddGroupHom
code: @[to_additive]
theorem MonoidHom.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (f : G →* H) :
    IsGroupHom (f : G → H) 
goal: ∀ {x : AddGroup G} {x_1 : AddGroup H} (f : G →+ H), IsAddGroupHom ⇑f

full_name: MonoidHom.isGroupHom
code: @[to_additive]
theorem MonoidHom.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (f : G →* H) :
    IsGroupHom (f : G → H) 
goal: ∀ {x : Group G} {x_1 : Group H} (f : G →* H), IsGroupHom ⇑f

full_name: MulEquiv.isGroupHom
code: @[to_additive]
theorem MulEquiv.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (h : G ≃* H) :
    IsGroupHom h 
goal: ∀ {x : Group G} {x_1 : Group H} (h : G ≃* H), IsGroupHom ⇑h

full_name: AddEquiv.isAddGroupHom
code: @[to_additive]
theorem MulEquiv.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (h : G ≃* H) :
    IsGroupHom h 
goal: ∀ {x : AddGroup G} {x_1 : AddGroup H} (h : G ≃+ H), IsAddGroupHom ⇑h

full_name: IsGroupHom.mk'
code: /-- Construct `IsGroupHom` from its only hypothesis. -/
@[to_additive "Construct `IsAddGroupHom` from its only hypothesis."]
theorem IsGroupHom.mk' [Group α] [Group β] {f : α → β} (hf : ∀ x y, f (x * y) = f x * f y) :
    IsGroupHom f 
goal: IsGroupHom f

full_name: IsAddGroupHom.mk'
code: /-- Construct `IsGroupHom` from its only hypothesis. -/
@[to_additive "Construct `IsAddGroupHom` from its only hypothesis."]
theorem IsGroupHom.mk' [Group α] [Group β] {f : α → β} (hf : ∀ x y, f (x * y) = f x * f y) :
    IsGroupHom f 
goal: IsAddGroupHom f

full_name: IsGroupHom.map_mul'
code: theorem map_mul' : ∀ x y, f (x * y) = f x * f y 
goal: f (x * y) = f x * f y

full_name: IsGroupHom.to_isMonoidHom
code: /-- A group homomorphism is a monoid homomorphism. -/
@[to_additive "An additive group homomorphism is an additive monoid homomorphism."]
theorem to_isMonoidHom : IsMonoidHom f 
goal: IsMonoidHom f

full_name: IsAddGroupHom.to_isAddMonoidHom
code: /-- A group homomorphism is a monoid homomorphism. -/
@[to_additive "An additive group homomorphism is an additive monoid homomorphism."]
theorem to_isMonoidHom : IsMonoidHom f 
goal: IsAddMonoidHom f

full_name: IsGroupHom.map_one
code: /-- A group homomorphism sends 1 to 1. -/
@[to_additive "An additive group homomorphism sends 0 to 0."]
theorem map_one : f 1 = 1 
goal: f 1 = 1

full_name: IsAddGroupHom.map_zero
code: /-- A group homomorphism sends 1 to 1. -/
@[to_additive "An additive group homomorphism sends 0 to 0."]
theorem map_one : f 1 = 1 
goal: f 0 = 0

full_name: IsGroupHom.map_inv
code: /-- A group homomorphism sends inverses to inverses. -/
@[to_additive "An additive group homomorphism sends negations to negations."]
theorem map_inv (hf : IsGroupHom f) (a : α) : f a⁻¹ = (f a)⁻¹ 
goal: f a⁻¹ = (f a)⁻¹

full_name: IsAddGroupHom.map_neg
code: /-- A group homomorphism sends inverses to inverses. -/
@[to_additive "An additive group homomorphism sends negations to negations."]
theorem map_inv (hf : IsGroupHom f) (a : α) : f a⁻¹ = (f a)⁻¹ 
goal: f (-a) = -f a

full_name: IsGroupHom.map_div
code: @[to_additive]
theorem map_div (hf : IsGroupHom f) (a b : α) : f (a / b) = f a / f b 
goal: f (a / b) = f a / f b

full_name: IsAddGroupHom.map_sub
code: @[to_additive]
theorem map_div (hf : IsGroupHom f) (a b : α) : f (a / b) = f a / f b 
goal: f (a - b) = f a - f b

full_name: IsAddGroupHom.id
code: /-- The identity is a group homomorphism. -/
@[to_additive "The identity is an additive group homomorphism."]
theorem id : IsGroupHom (@id α) 
goal: IsAddGroupHom id

full_name: IsGroupHom.id
code: /-- The identity is a group homomorphism. -/
@[to_additive "The identity is an additive group homomorphism."]
theorem id : IsGroupHom (@id α) 
goal: IsGroupHom id

full_name: IsAddGroupHom.comp
code: /-- The composition of two group homomorphisms is a group homomorphism. -/
@[to_additive
      "The composition of two additive group homomorphisms is an additive
      group homomorphism."]
theorem comp (hf : IsGroupHom f) {γ} [Group γ] {g : β → γ} (hg : IsGroupHom g) :
    IsGroupHom (g ∘ f) 
goal: IsAddGroupHom (g ∘ f)

full_name: IsGroupHom.comp
code: /-- The composition of two group homomorphisms is a group homomorphism. -/
@[to_additive
      "The composition of two additive group homomorphisms is an additive
      group homomorphism."]
theorem comp (hf : IsGroupHom f) {γ} [Group γ] {g : β → γ} (hg : IsGroupHom g) :
    IsGroupHom (g ∘ f) 
goal: IsGroupHom (g ∘ f)

full_name: IsAddGroupHom.injective_iff
code: /-- A group homomorphism is injective iff its kernel is trivial. -/
@[to_additive "An additive group homomorphism is injective if its kernel is trivial."]
theorem injective_iff {f : α → β} (hf : IsGroupHom f) :
    Function.Injective f ↔ ∀ a, f a = 1 → a = 1 
goal: Function.Injective f ↔ ∀ (a : α), f a = 0 → a = 0

full_name: IsGroupHom.injective_iff
code: /-- A group homomorphism is injective iff its kernel is trivial. -/
@[to_additive "An additive group homomorphism is injective if its kernel is trivial."]
theorem injective_iff {f : α → β} (hf : IsGroupHom f) :
    Function.Injective f ↔ ∀ a, f a = 1 → a = 1 
goal: Function.Injective f ↔ ∀ (a : α), f a = 1 → a = 1

full_name: IsAddGroupHom.add
code: /-- The product of group homomorphisms is a group homomorphism if the target is commutative. -/
@[to_additive
      "The sum of two additive group homomorphisms is an additive group homomorphism
      if the target is commutative."]
theorem mul {α β} [Group α] [CommGroup β] {f g : α → β} (hf : IsGroupHom f) (hg : IsGroupHom g) :
    IsGroupHom fun a => f a * g a 
goal: IsAddGroupHom fun a => f a + g a

full_name: IsGroupHom.mul
code: /-- The product of group homomorphisms is a group homomorphism if the target is commutative. -/
@[to_additive
      "The sum of two additive group homomorphisms is an additive group homomorphism
      if the target is commutative."]
theorem mul {α β} [Group α] [CommGroup β] {f g : α → β} (hf : IsGroupHom f) (hg : IsGroupHom g) :
    IsGroupHom fun a => f a * g a 
goal: IsGroupHom fun a => f a * g a

full_name: IsAddGroupHom.neg
code: /-- The inverse of a group homomorphism is a group homomorphism if the target is commutative. -/
@[to_additive
      "The negation of an additive group homomorphism is an additive group homomorphism
      if the target is commutative."]
theorem inv {α β} [Group α] [CommGroup β] {f : α → β} (hf : IsGroupHom f) :
    IsGroupHom fun a => (f a)⁻¹ 
goal: IsAddGroupHom fun a => -f a

full_name: IsGroupHom.inv
code: /-- The inverse of a group homomorphism is a group homomorphism if the target is commutative. -/
@[to_additive
      "The negation of an additive group homomorphism is an additive group homomorphism
      if the target is commutative."]
theorem inv {α β} [Group α] [CommGroup β] {f : α → β} (hf : IsGroupHom f) :
    IsGroupHom fun a => (f a)⁻¹ 
goal: IsGroupHom fun a => (f a)⁻¹

full_name: RingHom.to_isMonoidHom
code: theorem to_isMonoidHom (f : R →+* S) : IsMonoidHom f 
goal: IsMonoidHom ⇑f

full_name: RingHom.to_isAddMonoidHom
code: theorem to_isAddMonoidHom (f : R →+* S) : IsAddMonoidHom f 
goal: IsAddMonoidHom ⇑f

full_name: RingHom.to_isAddGroupHom
code: theorem to_isAddGroupHom (f : R →+* S) : IsAddGroupHom f 
goal: IsAddGroupHom ⇑f

full_name: Neg.isAddGroupHom
code: /-- Inversion is a group homomorphism if the group is commutative. -/
@[to_additive
      "Negation is an `AddGroup` homomorphism if the `AddGroup` is commutative."]
theorem Inv.isGroupHom [CommGroup α] : IsGroupHom (Inv.inv : α → α) 
goal: IsAddGroupHom Neg.neg

full_name: Inv.isGroupHom
code: /-- Inversion is a group homomorphism if the group is commutative. -/
@[to_additive
      "Negation is an `AddGroup` homomorphism if the `AddGroup` is commutative."]
theorem Inv.isGroupHom [CommGroup α] : IsGroupHom (Inv.inv : α → α) 
goal: IsGroupHom Inv.inv

full_name: IsAddGroupHom.sub
code: /-- The difference of two additive group homomorphisms is an additive group
homomorphism if the target is commutative. -/
theorem IsAddGroupHom.sub {α β} [AddGroup α] [AddCommGroup β] {f g : α → β} (hf : IsAddGroupHom f)
    (hg : IsAddGroupHom g) : IsAddGroupHom fun a => f a - g a 
goal: IsAddGroupHom fun a => f a - g a

full_name: Units.map'
code: /-- The group homomorphism on units induced by a multiplicative morphism. -/
abbrev map' {f : M → N} (hf : IsMonoidHom f) : Mˣ →* Nˣ 
goal: Mˣ →* Nˣ

full_name: Units.coe_map'
code: @[simp]
theorem coe_map' {f : M → N} (hf : IsMonoidHom f) (x : Mˣ) : ↑((map' hf : Mˣ → Nˣ) x) = f x 
goal: ↑((Units.map' hf) x) = f ↑x

full_name: Units.coe_isMonoidHom
code: theorem coe_isMonoidHom : IsMonoidHom (↑· : Mˣ → M) 
goal: IsMonoidHom fun x => ↑x

full_name: IsUnit.map'
code: theorem map' {f : M → N} (hf : IsMonoidHom f) {x : M} (h : IsUnit x) : IsUnit (f x) 
goal: IsUnit (f x)

full_name: Additive.isAddHom
code: theorem Additive.isAddHom [Mul α] [Mul β] {f : α → β} (hf : IsMulHom f) :
    @IsAddHom (Additive α) (Additive β) _ _ f 
goal: IsAddHom f

full_name: Multiplicative.isMulHom
code: theorem Multiplicative.isMulHom [Add α] [Add β] {f : α → β} (hf : IsAddHom f) :
    @IsMulHom (Multiplicative α) (Multiplicative β) _ _ f 
goal: IsMulHom f

full_name: Additive.isAddMonoidHom
code: theorem Additive.isAddMonoidHom [MulOneClass α] [MulOneClass β] {f : α → β}
    (hf : IsMonoidHom f) : @IsAddMonoidHom (Additive α) (Additive β) _ _ f 
goal: IsAddMonoidHom f

full_name: Multiplicative.isMonoidHom
code: theorem Multiplicative.isMonoidHom [AddZeroClass α] [AddZeroClass β] {f : α → β}
    (hf : IsAddMonoidHom f) : @IsMonoidHom (Multiplicative α) (Multiplicative β) _ _ f 
goal: IsMonoidHom f

full_name: Additive.isAddGroupHom
code: theorem Additive.isAddGroupHom [Group α] [Group β] {f : α → β} (hf : IsGroupHom f) :
    @IsAddGroupHom (Additive α) (Additive β) _ _ f 
goal: IsAddGroupHom f

full_name: Multiplicative.isGroupHom
code: theorem Multiplicative.isGroupHom [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f) :
    @IsGroupHom (Multiplicative α) (Multiplicative β) _ _ f 
goal: IsGroupHom f