ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IsMulHom.comp
@[to_additive "The composition of addition preserving maps also preserves addition"]
theorem comp {f : α → β} {g : β → γ} (hf : IsMulHom f) (hg : IsMulHom g) : IsMulHom (g ∘ f) 
Arguments: {α : Type u} {β : Type v} [Mul α] [Mul β] {γ : Type u_1} [Mul γ] {f : α → β} {g : β → γ} (hf : IsMulHom f) (hg : IsMulHom g)
Goal: IsMulHom (g ∘ f)
-- IsAddHom.comp
@[to_additive "The composition of addition preserving maps also preserves addition"]
theorem comp {f : α → β} {g : β → γ} (hf : IsMulHom f) (hg : IsMulHom g) : IsMulHom (g ∘ f) 
Arguments: {α : Type u} {β : Type v} [Add α] [Add β] {γ : Type u_1} [Add γ] {f : α → β} {g : β → γ} (hf : IsAddHom f) (hg : IsAddHom g)
Goal: IsAddHom (g ∘ f)
-- IsAddHom.add
@[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 
Arguments: {α : Type u_2} {β : Type u_3} [AddSemigroup α] [AddCommSemigroup β] {f g : α → β} (hf : IsAddHom f) (hg : IsAddHom g)
Goal: IsAddHom fun a => f a + g a
-- IsMulHom.mul
@[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 
Arguments: {α : Type u_2} {β : Type u_3} [Semigroup α] [CommSemigroup β] {f g : α → β} (hf : IsMulHom f) (hg : IsMulHom g)
Goal: IsMulHom fun a => f a * g a
-- IsMulHom.inv
@[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)⁻¹ 
Arguments: {α : Type u_2} {β : Type u_3} [Mul α] [CommGroup β] {f : α → β} (hf : IsMulHom f)
Goal: IsMulHom fun a => (f a)⁻¹
-- IsAddHom.neg
@[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)⁻¹ 
Arguments: {α : Type u_2} {β : Type u_3} [Add α] [AddCommGroup β] {f : α → β} (hf : IsAddHom f)
Goal: IsAddHom fun a => -f a
-- IsAddMonoidHom.map_zero
structure IsAddMonoidHom [AddZeroClass α] [AddZeroClass β] (f : α → β) extends IsAddHom f :
  Prop where
    map_zero : f 0 = 0
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddZeroClass β] {f : α → β} (self : IsAddMonoidHom f)
Goal: f 0 = 0
-- IsMonoidHom.map_one
@[to_additive]
structure IsMonoidHom [MulOneClass α] [MulOneClass β] (f : α → β) extends IsMulHom f : Prop where
    map_one : f 1 = 1
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [MulOneClass β] {f : α → β} (self : IsMonoidHom f)
Goal: f 1 = 1
-- AddMonoidHom.coe_of
@[to_additive (attr := simp)]
theorem coe_of {f : M → N} (hf : IsMonoidHom f) : ⇑(MonoidHom.of hf) = f 
Arguments: {M : Type u_1} {N : Type u_2} {mM : AddZeroClass M} {mN : AddZeroClass N} {f : M → N} (hf : IsAddMonoidHom f)
Goal: ⇑(AddMonoidHom.of hf) = f
-- MonoidHom.coe_of
@[to_additive (attr := simp)]
theorem coe_of {f : M → N} (hf : IsMonoidHom f) : ⇑(MonoidHom.of hf) = f 
Arguments: {M : Type u_1} {N : Type u_2} {mM : MulOneClass M} {mN : MulOneClass N} {f : M → N} (hf : IsMonoidHom f)
Goal: ⇑(MonoidHom.of hf) = f
-- AddMonoidHom.isAddMonoidHom_coe
@[to_additive]
theorem isMonoidHom_coe (f : M →* N) : IsMonoidHom (f : M → N) 
Arguments: {M : Type u_1} {N : Type u_2} {mM : AddZeroClass M} {mN : AddZeroClass N} (f : M →+ N)
Goal: IsAddMonoidHom ⇑f
-- MonoidHom.isMonoidHom_coe
@[to_additive]
theorem isMonoidHom_coe (f : M →* N) : IsMonoidHom (f : M → N) 
Arguments: {M : Type u_1} {N : Type u_2} {mM : MulOneClass M} {mN : MulOneClass N} (f : M →* N)
Goal: IsMonoidHom ⇑f
-- AddEquiv.isAddHom
@[to_additive "An additive isomorphism preserves addition (deprecated)."]
theorem isMulHom (h : M ≃* N) : IsMulHom h 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (h : M ≃+ N)
Goal: IsAddHom ⇑h
-- MulEquiv.isMulHom
@[to_additive "An additive isomorphism preserves addition (deprecated)."]
theorem isMulHom (h : M ≃* N) : IsMulHom h 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (h : M ≃* N)
Goal: IsMulHom ⇑h
-- MulEquiv.isMonoidHom
@[to_additive
      "An additive bijection between two additive monoids is an additive
      monoid hom (deprecated). "]
theorem isMonoidHom (h : M ≃* N) : IsMonoidHom h 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (h : M ≃* N)
Goal: IsMonoidHom ⇑h
-- AddEquiv.isAddMonoidHom
@[to_additive
      "An additive bijection between two additive monoids is an additive
      monoid hom (deprecated). "]
theorem isMonoidHom (h : M ≃* N) : IsMonoidHom h 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (h : M ≃+ N)
Goal: IsAddMonoidHom ⇑h
-- IsMonoidHom.map_mul'
@[to_additive "An additive monoid homomorphism preserves addition."]
theorem map_mul' (x y) : f (x * y) = f x * f y 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [MulOneClass β] {f : α → β} (hf : IsMonoidHom f) (x y : α)
Goal: f (x * y) = f x * f y
-- IsAddMonoidHom.map_add'
@[to_additive "An additive monoid homomorphism preserves addition."]
theorem map_mul' (x y) : f (x * y) = f x * f y 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddZeroClass β] {f : α → β} (hf : IsAddMonoidHom f) (x y : α)
Goal: f (x + y) = f x + f y
-- IsAddMonoidHom.neg
@[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)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} [AddZeroClass α] [AddCommGroup β] {f : α → β} (hf : IsAddMonoidHom f)
Goal: IsAddMonoidHom fun a => -f a
-- IsMonoidHom.inv
@[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)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} [MulOneClass α] [CommGroup β] {f : α → β} (hf : IsMonoidHom f)
Goal: IsMonoidHom fun a => (f a)⁻¹
-- IsMulHom.to_isMonoidHom
@[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 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [Group β] {f : α → β} (hf : IsMulHom f)
Goal: IsMonoidHom f
-- IsAddHom.to_isAddMonoidHom
@[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 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddGroup β] {f : α → β} (hf : IsAddHom f)
Goal: IsAddMonoidHom f
-- IsMonoidHom.id
@[to_additive "The identity map is an additive monoid homomorphism."]
theorem id : IsMonoidHom (@id α) 
Arguments: {α : Type u} [MulOneClass α]
Goal: IsMonoidHom id
-- IsAddMonoidHom.id
@[to_additive "The identity map is an additive monoid homomorphism."]
theorem id : IsMonoidHom (@id α) 
Arguments: {α : Type u} [AddZeroClass α]
Goal: IsAddMonoidHom id
-- IsAddMonoidHom.comp
@[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) 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddZeroClass β] {f : α → β} (hf : IsAddMonoidHom f) {γ : Type u_1} [AddZeroClass γ] {g : β → γ} (hg : IsAddMonoidHom g)
Goal: IsAddMonoidHom (g ∘ f)
-- IsMonoidHom.comp
@[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) 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [MulOneClass β] {f : α → β} (hf : IsMonoidHom f) {γ : Type u_1} [MulOneClass γ] {g : β → γ} (hg : IsMonoidHom g)
Goal: IsMonoidHom (g ∘ f)
-- IsAddMonoidHom.isAddMonoidHom_mul_left
theorem isAddMonoidHom_mul_left {γ : Type*} [NonUnitalNonAssocSemiring γ] (x : γ) :
    IsAddMonoidHom fun y : γ => x * y 
Arguments: {γ : Type u_1} [NonUnitalNonAssocSemiring γ] (x : γ)
Goal: IsAddMonoidHom fun y => x * y
-- IsAddMonoidHom.isAddMonoidHom_mul_right
theorem isAddMonoidHom_mul_right {γ : Type*} [NonUnitalNonAssocSemiring γ] (x : γ) :
    IsAddMonoidHom fun y : γ => y * x 
Arguments: {γ : Type u_1} [NonUnitalNonAssocSemiring γ] (x : γ)
Goal: IsAddMonoidHom fun y => y * x
-- AddMonoidHom.isAddGroupHom
@[to_additive]
theorem MonoidHom.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (f : G →* H) :
    IsGroupHom (f : G → H) 
Arguments: {G : Type u_1} {H : Type u_2}
Goal: ∀ {x : AddGroup G} {x_1 : AddGroup H} (f : G →+ H), IsAddGroupHom ⇑f
-- MonoidHom.isGroupHom
@[to_additive]
theorem MonoidHom.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (f : G →* H) :
    IsGroupHom (f : G → H) 
Arguments: {G : Type u_1} {H : Type u_2}
Goal: ∀ {x : Group G} {x_1 : Group H} (f : G →* H), IsGroupHom ⇑f
-- MulEquiv.isGroupHom
@[to_additive]
theorem MulEquiv.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (h : G ≃* H) :
    IsGroupHom h 
Arguments: {G : Type u_1} {H : Type u_2}
Goal: ∀ {x : Group G} {x_1 : Group H} (h : G ≃* H), IsGroupHom ⇑h
-- AddEquiv.isAddGroupHom
@[to_additive]
theorem MulEquiv.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (h : G ≃* H) :
    IsGroupHom h 
Arguments: {G : Type u_1} {H : Type u_2}
Goal: ∀ {x : AddGroup G} {x_1 : AddGroup H} (h : G ≃+ H), IsAddGroupHom ⇑h
-- IsGroupHom.mk'
@[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 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : ∀ (x y : α), f (x * y) = f x * f y)
Goal: IsGroupHom f
-- IsAddGroupHom.mk'
@[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 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : ∀ (x y : α), f (x + y) = f x + f y)
Goal: IsAddGroupHom f
-- IsGroupHom.map_mul'
theorem map_mul' : ∀ x y, f (x * y) = f x * f y 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f) (x y : α)
Goal: f (x * y) = f x * f y
-- IsGroupHom.to_isMonoidHom
@[to_additive "An additive group homomorphism is an additive monoid homomorphism."]
theorem to_isMonoidHom : IsMonoidHom f 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f)
Goal: IsMonoidHom f
-- IsAddGroupHom.to_isAddMonoidHom
@[to_additive "An additive group homomorphism is an additive monoid homomorphism."]
theorem to_isMonoidHom : IsMonoidHom f 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f)
Goal: IsAddMonoidHom f
-- IsGroupHom.map_one
@[to_additive "An additive group homomorphism sends 0 to 0."]
theorem map_one : f 1 = 1 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f)
Goal: f 1 = 1
-- IsAddGroupHom.map_zero
@[to_additive "An additive group homomorphism sends 0 to 0."]
theorem map_one : f 1 = 1 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f)
Goal: f 0 = 0
-- IsGroupHom.map_inv
@[to_additive "An additive group homomorphism sends negations to negations."]
theorem map_inv (hf : IsGroupHom f) (a : α) : f a⁻¹ = (f a)⁻¹ 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f) (a : α)
Goal: f a⁻¹ = (f a)⁻¹
-- IsAddGroupHom.map_neg
@[to_additive "An additive group homomorphism sends negations to negations."]
theorem map_inv (hf : IsGroupHom f) (a : α) : f a⁻¹ = (f a)⁻¹ 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f) (a : α)
Goal: f (-a) = -f a
-- IsGroupHom.map_div
@[to_additive]
theorem map_div (hf : IsGroupHom f) (a b : α) : f (a / b) = f a / f b 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f) (a b : α)
Goal: f (a / b) = f a / f b
-- IsAddGroupHom.map_sub
@[to_additive]
theorem map_div (hf : IsGroupHom f) (a b : α) : f (a / b) = f a / f b 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f) (a b : α)
Goal: f (a - b) = f a - f b
-- IsAddGroupHom.id
@[to_additive "The identity is an additive group homomorphism."]
theorem id : IsGroupHom (@id α) 
Arguments: {α : Type u} [AddGroup α]
Goal: IsAddGroupHom id
-- IsGroupHom.id
@[to_additive "The identity is an additive group homomorphism."]
theorem id : IsGroupHom (@id α) 
Arguments: {α : Type u} [Group α]
Goal: IsGroupHom id
-- IsAddGroupHom.comp
@[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) 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f) {γ : Type u_1} [AddGroup γ] {g : β → γ} (hg : IsAddGroupHom g)
Goal: IsAddGroupHom (g ∘ f)
-- IsGroupHom.comp
@[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) 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f) {γ : Type u_1} [Group γ] {g : β → γ} (hg : IsGroupHom g)
Goal: IsGroupHom (g ∘ f)
-- IsAddGroupHom.injective_iff
@[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 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f)
Goal: Function.Injective f ↔ ∀ (a : α), f a = 0 → a = 0
-- IsGroupHom.injective_iff
@[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 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f)
Goal: Function.Injective f ↔ ∀ (a : α), f a = 1 → a = 1
-- IsAddGroupHom.add
@[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 
Arguments: {α : Type u_1} {β : Type u_2} [AddGroup α] [AddCommGroup β] {f g : α → β} (hf : IsAddGroupHom f) (hg : IsAddGroupHom g)
Goal: IsAddGroupHom fun a => f a + g a
-- IsGroupHom.mul
@[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 
Arguments: {α : Type u_1} {β : Type u_2} [Group α] [CommGroup β] {f g : α → β} (hf : IsGroupHom f) (hg : IsGroupHom g)
Goal: IsGroupHom fun a => f a * g a
-- IsAddGroupHom.neg
@[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)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} [AddGroup α] [AddCommGroup β] {f : α → β} (hf : IsAddGroupHom f)
Goal: IsAddGroupHom fun a => -f a
-- IsGroupHom.inv
@[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)⁻¹ 
Arguments: {α : Type u_1} {β : Type u_2} [Group α] [CommGroup β] {f : α → β} (hf : IsGroupHom f)
Goal: IsGroupHom fun a => (f a)⁻¹
-- RingHom.to_isMonoidHom
theorem to_isMonoidHom (f : R →+* S) : IsMonoidHom f 
Arguments: {R : Type u_1} {S : Type u_2} [NonAssocSemiring R] [NonAssocSemiring S] (f : R →+* S)
Goal: IsMonoidHom ⇑f
-- RingHom.to_isAddMonoidHom
theorem to_isAddMonoidHom (f : R →+* S) : IsAddMonoidHom f 
Arguments: {R : Type u_1} {S : Type u_2} [NonAssocSemiring R] [NonAssocSemiring S] (f : R →+* S)
Goal: IsAddMonoidHom ⇑f
-- RingHom.to_isAddGroupHom
theorem to_isAddGroupHom (f : R →+* S) : IsAddGroupHom f 
Arguments: {R : Type u_1} {S : Type u_2} [Ring R] [Ring S] (f : R →+* S)
Goal: IsAddGroupHom ⇑f
-- Neg.isAddGroupHom
@[to_additive
      "Negation is an `AddGroup` homomorphism if the `AddGroup` is commutative."]
theorem Inv.isGroupHom [CommGroup α] : IsGroupHom (Inv.inv : α → α) 
Arguments: {α : Type u} [AddCommGroup α]
Goal: IsAddGroupHom Neg.neg
-- Inv.isGroupHom
@[to_additive
      "Negation is an `AddGroup` homomorphism if the `AddGroup` is commutative."]
theorem Inv.isGroupHom [CommGroup α] : IsGroupHom (Inv.inv : α → α) 
Arguments: {α : Type u} [CommGroup α]
Goal: IsGroupHom Inv.inv
-- IsAddGroupHom.sub
theorem IsAddGroupHom.sub {α β} [AddGroup α] [AddCommGroup β] {f g : α → β} (hf : IsAddGroupHom f)
    (hg : IsAddGroupHom g) : IsAddGroupHom fun a => f a - g a 
Arguments: {α : Type u_1} {β : Type u_2} [AddGroup α] [AddCommGroup β] {f g : α → β} (hf : IsAddGroupHom f) (hg : IsAddGroupHom g)
Goal: IsAddGroupHom fun a => f a - g a
-- Units.coe_map'
@[simp]
theorem coe_map' {f : M → N} (hf : IsMonoidHom f) (x : Mˣ) : ↑((map' hf : Mˣ → Nˣ) x) = f x 
Arguments: {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] {f : M → N} (hf : IsMonoidHom f) (x : Mˣ)
Goal: ↑((Units.map' hf) x) = f ↑x
-- Units.coe_isMonoidHom
theorem coe_isMonoidHom : IsMonoidHom (↑· : Mˣ → M) 
Arguments: {M : Type u_1} [Monoid M]
Goal: IsMonoidHom fun x => ↑x
-- IsUnit.map'
theorem map' {f : M → N} (hf : IsMonoidHom f) {x : M} (h : IsUnit x) : IsUnit (f x) 
Arguments: {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] {f : M → N} (hf : IsMonoidHom f) {x : M} (h : IsUnit x)
Goal: IsUnit (f x)
-- Additive.isAddHom
theorem Additive.isAddHom [Mul α] [Mul β] {f : α → β} (hf : IsMulHom f) :
    @IsAddHom (Additive α) (Additive β) _ _ f 
Arguments: {α : Type u} {β : Type v} [Mul α] [Mul β] {f : α → β} (hf : IsMulHom f)
Goal: IsAddHom f
-- Multiplicative.isMulHom
theorem Multiplicative.isMulHom [Add α] [Add β] {f : α → β} (hf : IsAddHom f) :
    @IsMulHom (Multiplicative α) (Multiplicative β) _ _ f 
Arguments: {α : Type u} {β : Type v} [Add α] [Add β] {f : α → β} (hf : IsAddHom f)
Goal: IsMulHom f
-- Additive.isAddMonoidHom
theorem Additive.isAddMonoidHom [MulOneClass α] [MulOneClass β] {f : α → β}
    (hf : IsMonoidHom f) : @IsAddMonoidHom (Additive α) (Additive β) _ _ f 
Arguments: {α : Type u} {β : Type v} [MulOneClass α] [MulOneClass β] {f : α → β} (hf : IsMonoidHom f)
Goal: IsAddMonoidHom f
-- Multiplicative.isMonoidHom
theorem Multiplicative.isMonoidHom [AddZeroClass α] [AddZeroClass β] {f : α → β}
    (hf : IsAddMonoidHom f) : @IsMonoidHom (Multiplicative α) (Multiplicative β) _ _ f 
Arguments: {α : Type u} {β : Type v} [AddZeroClass α] [AddZeroClass β] {f : α → β} (hf : IsAddMonoidHom f)
Goal: IsMonoidHom f
-- Additive.isAddGroupHom
theorem Additive.isAddGroupHom [Group α] [Group β] {f : α → β} (hf : IsGroupHom f) :
    @IsAddGroupHom (Additive α) (Additive β) _ _ f 
Arguments: {α : Type u} {β : Type v} [Group α] [Group β] {f : α → β} (hf : IsGroupHom f)
Goal: IsAddGroupHom f
-- Multiplicative.isGroupHom
theorem Multiplicative.isGroupHom [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f) :
    @IsGroupHom (Multiplicative α) (Multiplicative β) _ _ f 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddGroup β] {f : α → β} (hf : IsAddGroupHom f)
Goal: IsGroupHom f
-- IsAddSubmonoid.zero_mem
structure IsAddSubmonoid (s : Set A) : Prop where
    zero_mem : (0 : A) ∈ s
    add_mem {a b} : a ∈ s → b ∈ s → a + b ∈ s
Arguments: {A : Type u_2} [AddMonoid A] {s : Set A} (self : IsAddSubmonoid s)
Goal: 0 ∈ s
-- IsAddSubmonoid.add_mem
structure IsAddSubmonoid (s : Set A) : Prop where
    zero_mem : (0 : A) ∈ s
    add_mem {a b} : a ∈ s → b ∈ s → a + b ∈ s
Arguments: {A : Type u_2} [AddMonoid A] {s : Set A} (self : IsAddSubmonoid s) {a b : A}
Goal: a ∈ s → b ∈ s → a + b ∈ s
-- IsSubmonoid.one_mem
@[to_additive]
structure IsSubmonoid (s : Set M) : Prop where
    one_mem : (1 : M) ∈ s
    mul_mem {a b} : a ∈ s → b ∈ s → a * b ∈ s
Arguments: {M : Type u_1} [Monoid M] {s : Set M} (self : IsSubmonoid s)
Goal: 1 ∈ s
-- IsSubmonoid.mul_mem
@[to_additive]
structure IsSubmonoid (s : Set M) : Prop where
    one_mem : (1 : M) ∈ s
    mul_mem {a b} : a ∈ s → b ∈ s → a * b ∈ s
Arguments: {M : Type u_1} [Monoid M] {s : Set M} (self : IsSubmonoid s) {a b : M}
Goal: a ∈ s → b ∈ s → a * b ∈ s
-- Additive.isAddSubmonoid
theorem Additive.isAddSubmonoid {s : Set M} :
    IsSubmonoid s → @IsAddSubmonoid (Additive M) _ s
  
Arguments: {M : Type u_1} [Monoid M] {s : Set M}
Goal: IsSubmonoid s → IsAddSubmonoid s
-- Additive.isAddSubmonoid_iff
theorem Additive.isAddSubmonoid_iff {s : Set M} :
    @IsAddSubmonoid (Additive M) _ s ↔ IsSubmonoid s 
Arguments: {M : Type u_1} [Monoid M] {s : Set M}
Goal: IsAddSubmonoid s ↔ IsSubmonoid s
-- Multiplicative.isSubmonoid
theorem Multiplicative.isSubmonoid {s : Set A} :
    IsAddSubmonoid s → @IsSubmonoid (Multiplicative A) _ s
  
Arguments: {A : Type u_2} [AddMonoid A] {s : Set A}
Goal: IsAddSubmonoid s → IsSubmonoid s
-- Multiplicative.isSubmonoid_iff
theorem Multiplicative.isSubmonoid_iff {s : Set A} :
    @IsSubmonoid (Multiplicative A) _ s ↔ IsAddSubmonoid s 
Arguments: {A : Type u_2} [AddMonoid A] {s : Set A}
Goal: IsSubmonoid s ↔ IsAddSubmonoid s
-- IsAddSubmonoid.inter
@[to_additive
      "The intersection of two `AddSubmonoid`s of an `AddMonoid` `M` is an `AddSubmonoid` of M."]
theorem IsSubmonoid.inter {s₁ s₂ : Set M} (is₁ : IsSubmonoid s₁) (is₂ : IsSubmonoid s₂) :
    IsSubmonoid (s₁ ∩ s₂) 
Arguments: {M : Type u_1} [AddMonoid M] {s₁ s₂ : Set M} (is₁ : IsAddSubmonoid s₁) (is₂ : IsAddSubmonoid s₂)
Goal: IsAddSubmonoid (s₁ ∩ s₂)
-- IsSubmonoid.inter
@[to_additive
      "The intersection of two `AddSubmonoid`s of an `AddMonoid` `M` is an `AddSubmonoid` of M."]
theorem IsSubmonoid.inter {s₁ s₂ : Set M} (is₁ : IsSubmonoid s₁) (is₂ : IsSubmonoid s₂) :
    IsSubmonoid (s₁ ∩ s₂) 
Arguments: {M : Type u_1} [Monoid M] {s₁ s₂ : Set M} (is₁ : IsSubmonoid s₁) (is₂ : IsSubmonoid s₂)
Goal: IsSubmonoid (s₁ ∩ s₂)
-- IsSubmonoid.iInter
@[to_additive
      "The intersection of an indexed set of `AddSubmonoid`s of an `AddMonoid` `M` is
      an `AddSubmonoid` of `M`."]
theorem IsSubmonoid.iInter {ι : Sort*} {s : ι → Set M} (h : ∀ y : ι, IsSubmonoid (s y)) :
    IsSubmonoid (Set.iInter s) 
Arguments: {M : Type u_1} [Monoid M] {ι : Sort u_3} {s : ι → Set M} (h : ∀ (y : ι), IsSubmonoid (s y))
Goal: IsSubmonoid (Set.iInter s)
-- IsAddSubmonoid.iInter
@[to_additive
      "The intersection of an indexed set of `AddSubmonoid`s of an `AddMonoid` `M` is
      an `AddSubmonoid` of `M`."]
theorem IsSubmonoid.iInter {ι : Sort*} {s : ι → Set M} (h : ∀ y : ι, IsSubmonoid (s y)) :
    IsSubmonoid (Set.iInter s) 
Arguments: {M : Type u_1} [AddMonoid M] {ι : Sort u_3} {s : ι → Set M} (h : ∀ (y : ι), IsAddSubmonoid (s y))
Goal: IsAddSubmonoid (Set.iInter s)
-- isSubmonoid_iUnion_of_directed
@[to_additive
      "The union of an indexed, directed, nonempty set of `AddSubmonoid`s of an `AddMonoid` `M`
      is an `AddSubmonoid` of `M`. "]
theorem isSubmonoid_iUnion_of_directed {ι : Type*} [hι : Nonempty ι] {s : ι → Set M}
    (hs : ∀ i, IsSubmonoid (s i)) (Directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubmonoid (⋃ i, s i) 
Arguments: {M : Type u_1} [Monoid M] {ι : Type u_3} [hι : Nonempty ι] {s : ι → Set M} (hs : ∀ (i : ι), IsSubmonoid (s i)) (Directed : ∀ (i j : ι), ∃ k, s i ⊆ s k ∧ s j ⊆ s k)
Goal: IsSubmonoid (⋃ i, s i)