ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddSubmonoid.comap_equiv_eq_map_symm
@[to_additive]
theorem comap_equiv_eq_map_symm (f : N ≃* M) (K : Submonoid M) :
    K.comap f = K.map f.symm 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : N ≃+ M) (K : AddSubmonoid M)
Goal: AddSubmonoid.comap f K = AddSubmonoid.map f.symm K
-- Submonoid.comap_equiv_eq_map_symm
@[to_additive]
theorem comap_equiv_eq_map_symm (f : N ≃* M) (K : Submonoid M) :
    K.comap f = K.map f.symm 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : N ≃* M) (K : Submonoid M)
Goal: Submonoid.comap f K = Submonoid.map f.symm K
-- Submonoid.map_equiv_top
@[to_additive (attr := simp)]
theorem map_equiv_top (f : M ≃* N) : (⊤ : Submonoid M).map f = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M ≃* N)
Goal: Submonoid.map f ⊤ = ⊤
-- AddSubmonoid.map_equiv_top
@[to_additive (attr := simp)]
theorem map_equiv_top (f : M ≃* N) : (⊤ : Submonoid M).map f = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M ≃+ N)
Goal: AddSubmonoid.map f ⊤ = ⊤
-- Submonoid.le_prod_iff
@[to_additive le_prod_iff]
theorem le_prod_iff {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)} :
    u ≤ s.prod t ↔ u.map (fst M N) ≤ s ∧ u.map (snd M N) ≤ t 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)}
Goal: u ≤ s.prod t ↔ Submonoid.map (MonoidHom.fst M N) u ≤ s ∧ Submonoid.map (MonoidHom.snd M N) u ≤ t
-- AddSubmonoid.le_prod_iff
@[to_additive le_prod_iff]
theorem le_prod_iff {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)} :
    u ≤ s.prod t ↔ u.map (fst M N) ≤ s ∧ u.map (snd M N) ≤ t 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {s : AddSubmonoid M} {t : AddSubmonoid N} {u : AddSubmonoid (M × N)}
Goal: u ≤ s.prod t ↔ AddSubmonoid.map (AddMonoidHom.fst M N) u ≤ s ∧ AddSubmonoid.map (AddMonoidHom.snd M N) u ≤ t
-- Submonoid.prod_le_iff
@[to_additive prod_le_iff]
theorem prod_le_iff {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)} :
    s.prod t ≤ u ↔ s.map (inl M N) ≤ u ∧ t.map (inr M N) ≤ u 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)}
Goal: s.prod t ≤ u ↔ Submonoid.map (MonoidHom.inl M N) s ≤ u ∧ Submonoid.map (MonoidHom.inr M N) t ≤ u
-- AddSubmonoid.prod_le_iff
@[to_additive prod_le_iff]
theorem prod_le_iff {s : Submonoid M} {t : Submonoid N} {u : Submonoid (M × N)} :
    s.prod t ≤ u ↔ s.map (inl M N) ≤ u ∧ t.map (inr M N) ≤ u 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {s : AddSubmonoid M} {t : AddSubmonoid N} {u : AddSubmonoid (M × N)}
Goal: s.prod t ≤ u ↔ AddSubmonoid.map (AddMonoidHom.inl M N) s ≤ u ∧ AddSubmonoid.map (AddMonoidHom.inr M N) t ≤ u
-- MonoidHom.coe_mrange
@[to_additive (attr := simp)]
theorem coe_mrange (f : F) : (mrange f : Set N) = Set.range f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F)
Goal: ↑(MonoidHom.mrange f) = Set.range ⇑f
-- AddMonoidHom.coe_mrange
@[to_additive (attr := simp)]
theorem coe_mrange (f : F) : (mrange f : Set N) = Set.range f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F)
Goal: ↑(AddMonoidHom.mrange f) = Set.range ⇑f
-- MonoidHom.mem_mrange
@[to_additive (attr := simp)]
theorem mem_mrange {f : F} {y : N} : y ∈ mrange f ↔ ∃ x, f x = y 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {y : N}
Goal: y ∈ MonoidHom.mrange f ↔ ∃ x, f x = y
-- AddMonoidHom.mem_mrange
@[to_additive (attr := simp)]
theorem mem_mrange {f : F} {y : N} : y ∈ mrange f ↔ ∃ x, f x = y 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {y : N}
Goal: y ∈ AddMonoidHom.mrange f ↔ ∃ x, f x = y
-- MonoidHom.mrange_eq_map
@[to_additive]
theorem mrange_eq_map (f : F) : mrange f = (⊤ : Submonoid M).map f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F)
Goal: MonoidHom.mrange f = Submonoid.map f ⊤
-- AddMonoidHom.mrange_eq_map
@[to_additive]
theorem mrange_eq_map (f : F) : mrange f = (⊤ : Submonoid M).map f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F)
Goal: AddMonoidHom.mrange f = AddSubmonoid.map f ⊤
-- AddMonoidHom.mrange_id
@[to_additive (attr := simp)]
theorem mrange_id : mrange (MonoidHom.id M) = ⊤ 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: AddMonoidHom.mrange (AddMonoidHom.id M) = ⊤
-- MonoidHom.mrange_id
@[to_additive (attr := simp)]
theorem mrange_id : mrange (MonoidHom.id M) = ⊤ 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: MonoidHom.mrange (MonoidHom.id M) = ⊤
-- AddMonoidHom.map_mrange
@[to_additive]
theorem map_mrange (g : N →* P) (f : M →* N) : f.mrange.map g = mrange (comp g f) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (g : N →+ P) (f : M →+ N)
Goal: AddSubmonoid.map g (AddMonoidHom.mrange f) = AddMonoidHom.mrange (g.comp f)
-- MonoidHom.map_mrange
@[to_additive]
theorem map_mrange (g : N →* P) (f : M →* N) : f.mrange.map g = mrange (comp g f) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [MulOneClass P] (g : N →* P) (f : M →* N)
Goal: Submonoid.map g (MonoidHom.mrange f) = MonoidHom.mrange (g.comp f)
-- MonoidHom.mrange_top_iff_surjective
@[to_additive]
theorem mrange_top_iff_surjective {f : F} : mrange f = (⊤ : Submonoid N) ↔ Function.Surjective f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F}
Goal: MonoidHom.mrange f = ⊤ ↔ Function.Surjective ⇑f
-- AddMonoidHom.mrange_top_iff_surjective
@[to_additive]
theorem mrange_top_iff_surjective {f : F} : mrange f = (⊤ : Submonoid N) ↔ Function.Surjective f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F}
Goal: AddMonoidHom.mrange f = ⊤ ↔ Function.Surjective ⇑f
-- AddMonoidHom.mrange_top_of_surjective
@[to_additive (attr := simp)
  "The range of a surjective `AddMonoid` hom is the whole of the codomain."]
theorem mrange_top_of_surjective (f : F) (hf : Function.Surjective f) :
    mrange f = (⊤ : Submonoid N) 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (hf : Function.Surjective ⇑f)
Goal: AddMonoidHom.mrange f = ⊤
-- MonoidHom.mrange_top_of_surjective
@[to_additive (attr := simp)
  "The range of a surjective `AddMonoid` hom is the whole of the codomain."]
theorem mrange_top_of_surjective (f : F) (hf : Function.Surjective f) :
    mrange f = (⊤ : Submonoid N) 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (hf : Function.Surjective ⇑f)
Goal: MonoidHom.mrange f = ⊤
-- MonoidHom.mclosure_preimage_le
@[to_additive]
theorem mclosure_preimage_le (f : F) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (s : Set N)
Goal: Submonoid.closure (⇑f ⁻¹' s) ≤ Submonoid.comap f (Submonoid.closure s)
-- AddMonoidHom.mclosure_preimage_le
@[to_additive]
theorem mclosure_preimage_le (f : F) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (s : Set N)
Goal: AddSubmonoid.closure (⇑f ⁻¹' s) ≤ AddSubmonoid.comap f (AddSubmonoid.closure s)
-- AddMonoidHom.map_mclosure
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubmonoid` generated by a set equals
      the `AddSubmonoid` generated by the image of the set."]
theorem map_mclosure (f : F) (s : Set M) : (closure s).map f = closure (f '' s) 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (s : Set M)
Goal: AddSubmonoid.map f (AddSubmonoid.closure s) = AddSubmonoid.closure (⇑f '' s)
-- MonoidHom.map_mclosure
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubmonoid` generated by a set equals
      the `AddSubmonoid` generated by the image of the set."]
theorem map_mclosure (f : F) (s : Set M) : (closure s).map f = closure (f '' s) 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (s : Set M)
Goal: Submonoid.map f (Submonoid.closure s) = Submonoid.closure (⇑f '' s)
-- AddMonoidHom.mclosure_range
@[to_additive (attr := simp)]
theorem mclosure_range (f : F) : closure (Set.range f) = mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F)
Goal: AddSubmonoid.closure (Set.range ⇑f) = AddMonoidHom.mrange f
-- MonoidHom.mclosure_range
@[to_additive (attr := simp)]
theorem mclosure_range (f : F) : closure (Set.range f) = mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F)
Goal: Submonoid.closure (Set.range ⇑f) = MonoidHom.mrange f
-- MonoidHom.restrict_apply
@[to_additive (attr := simp)]
theorem restrict_apply {N S : Type*} [MulOneClass N] [SetLike S M] [SubmonoidClass S M]
    (f : M →* N) (s : S) (x : s) : f.restrict s x = f x 
Arguments: {M : Type u_1} [MulOneClass M] {N : Type u_6} {S : Type u_7} [MulOneClass N] [SetLike S M] [SubmonoidClass S M] (f : M →* N) (s : S) (x : ↥s)
Goal: (f.restrict s) x = f ↑x
-- AddMonoidHom.restrict_apply
@[to_additive (attr := simp)]
theorem restrict_apply {N S : Type*} [MulOneClass N] [SetLike S M] [SubmonoidClass S M]
    (f : M →* N) (s : S) (x : s) : f.restrict s x = f x 
Arguments: {M : Type u_1} [AddZeroClass M] {N : Type u_6} {S : Type u_7} [AddZeroClass N] [SetLike S M] [AddSubmonoidClass S M] (f : M →+ N) (s : S) (x : ↥s)
Goal: (f.restrict s) x = f ↑x
-- MonoidHom.restrict_mrange
@[to_additive (attr := simp)]
theorem restrict_mrange (f : M →* N) : mrange (f.restrict S) = S.map f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) (f : M →* N)
Goal: MonoidHom.mrange (f.restrict S) = Submonoid.map f S
-- AddMonoidHom.restrict_mrange
@[to_additive (attr := simp)]
theorem restrict_mrange (f : M →* N) : mrange (f.restrict S) = S.map f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) (f : M →+ N)
Goal: AddMonoidHom.mrange (f.restrict S) = AddSubmonoid.map f S
-- MonoidHom.codRestrict_apply
@[to_additive (attr := simps apply)
  "Restriction of an `AddMonoid` hom to an `AddSubmonoid` of the codomain."]
def codRestrict {S} [SetLike S N] [SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ x, f x ∈ s) :
    M →* s 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {S : Type u_6} [SetLike S N] [SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x ∈ s) (n : M)
Goal: (f.codRestrict s h) n = ⟨f n, ⋯⟩
-- AddMonoidHom.codRestrict_apply
@[to_additive (attr := simps apply)
  "Restriction of an `AddMonoid` hom to an `AddSubmonoid` of the codomain."]
def codRestrict {S} [SetLike S N] [SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ x, f x ∈ s) :
    M →* s 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {S : Type u_6} [SetLike S N] [AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x ∈ s) (n : M)
Goal: (f.codRestrict s h) n = ⟨f n, ⋯⟩
-- AddMonoidHom.coe_mrangeRestrict
@[to_additive (attr := simp)]
theorem coe_mrangeRestrict {N} [MulOneClass N] (f : M →* N) (x : M) :
    (f.mrangeRestrict x : N) = f x 
Arguments: {M : Type u_1} [AddZeroClass M] {N : Type u_6} [AddZeroClass N] (f : M →+ N) (x : M)
Goal: ↑(f.mrangeRestrict x) = f x
-- MonoidHom.coe_mrangeRestrict
@[to_additive (attr := simp)]
theorem coe_mrangeRestrict {N} [MulOneClass N] (f : M →* N) (x : M) :
    (f.mrangeRestrict x : N) = f x 
Arguments: {M : Type u_1} [MulOneClass M] {N : Type u_6} [MulOneClass N] (f : M →* N) (x : M)
Goal: ↑(f.mrangeRestrict x) = f x
-- AddMonoidHom.mrangeRestrict_surjective
@[to_additive]
theorem mrangeRestrict_surjective (f : M →* N) : Function.Surjective f.mrangeRestrict 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N)
Goal: Function.Surjective ⇑f.mrangeRestrict
-- MonoidHom.mrangeRestrict_surjective
@[to_additive]
theorem mrangeRestrict_surjective (f : M →* N) : Function.Surjective f.mrangeRestrict 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N)
Goal: Function.Surjective ⇑f.mrangeRestrict
-- MonoidHom.mem_mker
@[to_additive]
theorem mem_mker (f : F) {x : M} : x ∈ mker f ↔ f x = 1 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) {x : M}
Goal: x ∈ MonoidHom.mker f ↔ f x = 1
-- AddMonoidHom.mem_mker
@[to_additive]
theorem mem_mker (f : F) {x : M} : x ∈ mker f ↔ f x = 1 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) {x : M}
Goal: x ∈ AddMonoidHom.mker f ↔ f x = 0
-- MonoidHom.coe_mker
@[to_additive]
theorem coe_mker (f : F) : (mker f : Set M) = (f : M → N) ⁻¹' {1} 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F)
Goal: ↑(MonoidHom.mker f) = ⇑f ⁻¹' {1}
-- AddMonoidHom.coe_mker
@[to_additive]
theorem coe_mker (f : F) : (mker f : Set M) = (f : M → N) ⁻¹' {1} 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F)
Goal: ↑(AddMonoidHom.mker f) = ⇑f ⁻¹' {0}
-- AddMonoidHom.comap_mker
@[to_additive]
theorem comap_mker (g : N →* P) (f : M →* N) : g.mker.comap f = mker (comp g f) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddZeroClass P] (g : N →+ P) (f : M →+ N)
Goal: AddSubmonoid.comap f (AddMonoidHom.mker g) = AddMonoidHom.mker (g.comp f)
-- MonoidHom.comap_mker
@[to_additive]
theorem comap_mker (g : N →* P) (f : M →* N) : g.mker.comap f = mker (comp g f) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [MulOneClass P] (g : N →* P) (f : M →* N)
Goal: Submonoid.comap f (MonoidHom.mker g) = MonoidHom.mker (g.comp f)
-- AddMonoidHom.comap_bot'
@[to_additive (attr := simp)]
theorem comap_bot' (f : F) : (⊥ : Submonoid N).comap f = mker f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F)
Goal: AddSubmonoid.comap f ⊥ = AddMonoidHom.mker f
-- MonoidHom.comap_bot'
@[to_additive (attr := simp)]
theorem comap_bot' (f : F) : (⊥ : Submonoid N).comap f = mker f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F)
Goal: Submonoid.comap f ⊥ = MonoidHom.mker f
-- AddMonoidHom.restrict_mker
@[to_additive (attr := simp)]
theorem restrict_mker (f : M →* N) : mker (f.restrict S) = f.mker.comap S.subtype 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) (f : M →+ N)
Goal: AddMonoidHom.mker (f.restrict S) = AddSubmonoid.comap S.subtype (AddMonoidHom.mker f)
-- MonoidHom.restrict_mker
@[to_additive (attr := simp)]
theorem restrict_mker (f : M →* N) : mker (f.restrict S) = f.mker.comap S.subtype 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) (f : M →* N)
Goal: MonoidHom.mker (f.restrict S) = Submonoid.comap S.subtype (MonoidHom.mker f)
-- MonoidHom.mrangeRestrict_mker
@[to_additive]
theorem mrangeRestrict_mker (f : M →* N) : mker (mrangeRestrict f) = mker f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N)
Goal: MonoidHom.mker f.mrangeRestrict = MonoidHom.mker f
-- AddMonoidHom.mrangeRestrict_mker
@[to_additive]
theorem mrangeRestrict_mker (f : M →* N) : mker (mrangeRestrict f) = mker f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N)
Goal: AddMonoidHom.mker f.mrangeRestrict = AddMonoidHom.mker f
-- AddMonoidHom.mker_zero
@[to_additive (attr := simp)]
theorem mker_one : mker (1 : M →* N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mker 0 = ⊤
-- MonoidHom.mker_one
@[to_additive (attr := simp)]
theorem mker_one : mker (1 : M →* N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mker 1 = ⊤
-- AddMonoidHom.prod_map_comap_prod'
@[to_additive prod_map_comap_prod']
theorem prod_map_comap_prod' {M' : Type*} {N' : Type*} [MulOneClass M'] [MulOneClass N']
    (f : M →* N) (g : M' →* N') (S : Submonoid N) (S' : Submonoid N') :
    (S.prod S').comap (prodMap f g) = (S.comap f).prod (S'.comap g) 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {M' : Type u_6} {N' : Type u_7} [AddZeroClass M'] [AddZeroClass N'] (f : M →+ N) (g : M' →+ N') (S : AddSubmonoid N) (S' : AddSubmonoid N')
Goal: AddSubmonoid.comap (f.prodMap g) (S.prod S') = (AddSubmonoid.comap f S).prod (AddSubmonoid.comap g S')
-- MonoidHom.prod_map_comap_prod'
@[to_additive prod_map_comap_prod']
theorem prod_map_comap_prod' {M' : Type*} {N' : Type*} [MulOneClass M'] [MulOneClass N']
    (f : M →* N) (g : M' →* N') (S : Submonoid N) (S' : Submonoid N') :
    (S.prod S').comap (prodMap f g) = (S.comap f).prod (S'.comap g) 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {M' : Type u_6} {N' : Type u_7} [MulOneClass M'] [MulOneClass N'] (f : M →* N) (g : M' →* N') (S : Submonoid N) (S' : Submonoid N')
Goal: Submonoid.comap (f.prodMap g) (S.prod S') = (Submonoid.comap f S).prod (Submonoid.comap g S')
-- MonoidHom.mker_prod_map
@[to_additive mker_prod_map]
theorem mker_prod_map {M' : Type*} {N' : Type*} [MulOneClass M'] [MulOneClass N'] (f : M →* N)
    (g : M' →* N') : mker (prodMap f g) = f.mker.prod (mker g) 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {M' : Type u_6} {N' : Type u_7} [MulOneClass M'] [MulOneClass N'] (f : M →* N) (g : M' →* N')
Goal: MonoidHom.mker (f.prodMap g) = (MonoidHom.mker f).prod (MonoidHom.mker g)
-- AddMonoidHom.mker_prod_map
@[to_additive mker_prod_map]
theorem mker_prod_map {M' : Type*} {N' : Type*} [MulOneClass M'] [MulOneClass N'] (f : M →* N)
    (g : M' →* N') : mker (prodMap f g) = f.mker.prod (mker g) 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {M' : Type u_6} {N' : Type u_7} [AddZeroClass M'] [AddZeroClass N'] (f : M →+ N) (g : M' →+ N')
Goal: AddMonoidHom.mker (f.prodMap g) = (AddMonoidHom.mker f).prod (AddMonoidHom.mker g)
-- AddMonoidHom.mker_inl
@[to_additive (attr := simp)]
theorem mker_inl : mker (inl M N) = ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mker (AddMonoidHom.inl M N) = ⊥
-- MonoidHom.mker_inl
@[to_additive (attr := simp)]
theorem mker_inl : mker (inl M N) = ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mker (MonoidHom.inl M N) = ⊥
-- AddMonoidHom.mker_inr
@[to_additive (attr := simp)]
theorem mker_inr : mker (inr M N) = ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mker (AddMonoidHom.inr M N) = ⊥
-- MonoidHom.mker_inr
@[to_additive (attr := simp)]
theorem mker_inr : mker (inr M N) = ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mker (MonoidHom.inr M N) = ⊥
-- MonoidHom.mker_fst
@[to_additive (attr := simp)]
lemma mker_fst : mker (fst M N) = .prod ⊥ ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mker (MonoidHom.fst M N) = ⊥.prod ⊤
-- AddMonoidHom.mker_fst
@[to_additive (attr := simp)]
lemma mker_fst : mker (fst M N) = .prod ⊥ ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mker (AddMonoidHom.fst M N) = ⊥.prod ⊤
-- AddMonoidHom.mker_snd
@[to_additive (attr := simp)]
lemma mker_snd : mker (snd M N) = .prod ⊤ ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mker (AddMonoidHom.snd M N) = ⊤.prod ⊥
-- MonoidHom.mker_snd
@[to_additive (attr := simp)]
lemma mker_snd : mker (snd M N) = .prod ⊤ ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mker (MonoidHom.snd M N) = ⊤.prod ⊥
-- AddMonoidHom.addSubmonoidComap_apply_coe
@[to_additive (attr := simps)
      "the `AddMonoidHom` from the preimage of an additive submonoid to itself."]
def submonoidComap (f : M →* N) (N' : Submonoid N) :
    N'.comap f →* N' 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (N' : AddSubmonoid N) (x : ↥(AddSubmonoid.comap f N'))
Goal: ↑((f.addSubmonoidComap N') x) = f ↑x
-- MonoidHom.submonoidComap_apply_coe
@[to_additive (attr := simps)
      "the `AddMonoidHom` from the preimage of an additive submonoid to itself."]
def submonoidComap (f : M →* N) (N' : Submonoid N) :
    N'.comap f →* N' 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) (N' : Submonoid N) (x : ↥(Submonoid.comap f N'))
Goal: ↑((f.submonoidComap N') x) = f ↑x
-- MonoidHom.submonoidMap_apply_coe
@[to_additive (attr := simps)
      "the `AddMonoidHom` from an additive submonoid to its image. See
      `AddEquiv.AddSubmonoidMap` for a variant for `AddEquiv`s."]
def submonoidMap (f : M →* N) (M' : Submonoid M) : M' →* M'.map f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) (M' : Submonoid M) (x : ↥M')
Goal: ↑((f.submonoidMap M') x) = f ↑x
-- AddMonoidHom.addSubmonoidMap_apply_coe
@[to_additive (attr := simps)
      "the `AddMonoidHom` from an additive submonoid to its image. See
      `AddEquiv.AddSubmonoidMap` for a variant for `AddEquiv`s."]
def submonoidMap (f : M →* N) (M' : Submonoid M) : M' →* M'.map f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (M' : AddSubmonoid M) (x : ↥M')
Goal: ↑((f.addSubmonoidMap M') x) = f ↑x
-- MonoidHom.submonoidMap_surjective
@[to_additive]
theorem submonoidMap_surjective (f : M →* N) (M' : Submonoid M) :
    Function.Surjective (f.submonoidMap M') 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) (M' : Submonoid M)
Goal: Function.Surjective ⇑(f.submonoidMap M')
-- AddMonoidHom.addSubmonoidMap_surjective
@[to_additive]
theorem submonoidMap_surjective (f : M →* N) (M' : Submonoid M) :
    Function.Surjective (f.submonoidMap M') 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (M' : AddSubmonoid M)
Goal: Function.Surjective ⇑(f.addSubmonoidMap M')
-- Submonoid.mrange_inl
@[to_additive]
theorem mrange_inl : mrange (inl M N) = prod ⊤ ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mrange (MonoidHom.inl M N) = ⊤.prod ⊥
-- AddSubmonoid.mrange_inl
@[to_additive]
theorem mrange_inl : mrange (inl M N) = prod ⊤ ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mrange (AddMonoidHom.inl M N) = ⊤.prod ⊥
-- Submonoid.mrange_inr
@[to_additive]
theorem mrange_inr : mrange (inr M N) = prod ⊥ ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mrange (MonoidHom.inr M N) = ⊥.prod ⊤