File: Mathlib/Algebra/Group/Submonoid/Operations.lean

full_name: Submonoid.toAddSubmonoid_symm_apply_coe
code: /-- Submonoids of monoid `M` are isomorphic to additive submonoids of `Additive M`. -/
@[simps]
def Submonoid.toAddSubmonoid : Submonoid M ≃o AddSubmonoid (Additive M) 
goal: ↑((RelIso.symm Submonoid.toAddSubmonoid) S) = ⇑Additive.ofMul ⁻¹' ↑S

full_name: Submonoid.toAddSubmonoid
code: /-- Submonoids of monoid `M` are isomorphic to additive submonoids of `Additive M`. -/
@[simps]
def Submonoid.toAddSubmonoid : Submonoid M ≃o AddSubmonoid (Additive M) 
goal: Submonoid M ≃o AddSubmonoid (Additive M)

full_name: Submonoid.toAddSubmonoid_apply_coe
code: /-- Submonoids of monoid `M` are isomorphic to additive submonoids of `Additive M`. -/
@[simps]
def Submonoid.toAddSubmonoid : Submonoid M ≃o AddSubmonoid (Additive M) 
goal: ↑(Submonoid.toAddSubmonoid S) = ⇑Additive.toMul ⁻¹' ↑S

full_name: AddSubmonoid.toSubmonoid'
code: /-- Additive submonoids of an additive monoid `Additive M` are isomorphic to submonoids of `M`. -/
abbrev AddSubmonoid.toSubmonoid' : AddSubmonoid (Additive M) ≃o Submonoid M 
goal: AddSubmonoid (Additive M) ≃o Submonoid M

full_name: Submonoid.toAddSubmonoid_closure
code: theorem Submonoid.toAddSubmonoid_closure (S : Set M) :
    Submonoid.toAddSubmonoid (Submonoid.closure S)
      = AddSubmonoid.closure (Additive.toMul ⁻¹' S) 
goal: Submonoid.toAddSubmonoid (Submonoid.closure S) = AddSubmonoid.closure (⇑Additive.toMul ⁻¹' S)

full_name: AddSubmonoid.toSubmonoid'_closure
code: theorem AddSubmonoid.toSubmonoid'_closure (S : Set (Additive M)) :
    AddSubmonoid.toSubmonoid' (AddSubmonoid.closure S)
      = Submonoid.closure (Multiplicative.ofAdd ⁻¹' S) 
goal: AddSubmonoid.toSubmonoid' (AddSubmonoid.closure S) = Submonoid.closure (⇑Multiplicative.ofAdd ⁻¹' S)

full_name: AddSubmonoid.toSubmonoid_apply_coe
code: /-- Additive submonoids of an additive monoid `A` are isomorphic to
multiplicative submonoids of `Multiplicative A`. -/
@[simps]
def AddSubmonoid.toSubmonoid : AddSubmonoid A ≃o Submonoid (Multiplicative A) 
goal: ↑(AddSubmonoid.toSubmonoid S) = ⇑Multiplicative.toAdd ⁻¹' ↑S

full_name: AddSubmonoid.toSubmonoid_symm_apply_coe
code: /-- Additive submonoids of an additive monoid `A` are isomorphic to
multiplicative submonoids of `Multiplicative A`. -/
@[simps]
def AddSubmonoid.toSubmonoid : AddSubmonoid A ≃o Submonoid (Multiplicative A) 
goal: ↑((RelIso.symm AddSubmonoid.toSubmonoid) S) = ⇑Multiplicative.ofAdd ⁻¹' ↑S

full_name: AddSubmonoid.toSubmonoid
code: /-- Additive submonoids of an additive monoid `A` are isomorphic to
multiplicative submonoids of `Multiplicative A`. -/
@[simps]
def AddSubmonoid.toSubmonoid : AddSubmonoid A ≃o Submonoid (Multiplicative A) 
goal: AddSubmonoid A ≃o Submonoid (Multiplicative A)

full_name: Submonoid.toAddSubmonoid'
code: /-- Submonoids of a monoid `Multiplicative A` are isomorphic to additive submonoids of `A`. -/
abbrev Submonoid.toAddSubmonoid' : Submonoid (Multiplicative A) ≃o AddSubmonoid A 
goal: Submonoid (Multiplicative A) ≃o AddSubmonoid A

full_name: AddSubmonoid.toSubmonoid_closure
code: theorem AddSubmonoid.toSubmonoid_closure (S : Set A) :
    (AddSubmonoid.toSubmonoid) (AddSubmonoid.closure S)
      = Submonoid.closure (Multiplicative.toAdd ⁻¹' S) 
goal: AddSubmonoid.toSubmonoid (AddSubmonoid.closure S) = Submonoid.closure (⇑Multiplicative.toAdd ⁻¹' S)

full_name: Submonoid.toAddSubmonoid'_closure
code: theorem Submonoid.toAddSubmonoid'_closure (S : Set (Multiplicative A)) :
    Submonoid.toAddSubmonoid' (Submonoid.closure S)
      = AddSubmonoid.closure (Additive.ofMul ⁻¹' S) 
goal: Submonoid.toAddSubmonoid' (Submonoid.closure S) = AddSubmonoid.closure (⇑Additive.ofMul ⁻¹' S)

full_name: Submonoid.comap
code: /-- The preimage of a submonoid along a monoid homomorphism is a submonoid. -/
@[to_additive
      "The preimage of an `AddSubmonoid` along an `AddMonoid` homomorphism is an `AddSubmonoid`."]
def comap (f : F) (S : Submonoid N) :
    Submonoid M 
goal: Submonoid M

full_name: AddSubmonoid.comap
code: /-- The preimage of a submonoid along a monoid homomorphism is a submonoid. -/
@[to_additive
      "The preimage of an `AddSubmonoid` along an `AddMonoid` homomorphism is an `AddSubmonoid`."]
def comap (f : F) (S : Submonoid N) :
    Submonoid M 
goal: AddSubmonoid M

full_name: Submonoid.coe_comap
code: @[to_additive (attr := simp)]
theorem coe_comap (S : Submonoid N) (f : F) : (S.comap f : Set M) = f ⁻¹' S 
goal: ↑(Submonoid.comap f S) = ⇑f ⁻¹' ↑S

full_name: AddSubmonoid.coe_comap
code: @[to_additive (attr := simp)]
theorem coe_comap (S : Submonoid N) (f : F) : (S.comap f : Set M) = f ⁻¹' S 
goal: ↑(AddSubmonoid.comap f S) = ⇑f ⁻¹' ↑S

full_name: AddSubmonoid.mem_comap
code: @[to_additive (attr := simp)]
theorem mem_comap {S : Submonoid N} {f : F} {x : M} : x ∈ S.comap f ↔ f x ∈ S 
goal: x ∈ AddSubmonoid.comap f S ↔ f x ∈ S

full_name: Submonoid.mem_comap
code: @[to_additive (attr := simp)]
theorem mem_comap {S : Submonoid N} {f : F} {x : M} : x ∈ S.comap f ↔ f x ∈ S 
goal: x ∈ Submonoid.comap f S ↔ f x ∈ S

full_name: Submonoid.comap_comap
code: @[to_additive]
theorem comap_comap (S : Submonoid P) (g : N →* P) (f : M →* N) :
    (S.comap g).comap f = S.comap (g.comp f) 
goal: Submonoid.comap f (Submonoid.comap g S) = Submonoid.comap (g.comp f) S

full_name: AddSubmonoid.comap_comap
code: @[to_additive]
theorem comap_comap (S : Submonoid P) (g : N →* P) (f : M →* N) :
    (S.comap g).comap f = S.comap (g.comp f) 
goal: AddSubmonoid.comap f (AddSubmonoid.comap g S) = AddSubmonoid.comap (g.comp f) S

full_name: Submonoid.comap_id
code: @[to_additive (attr := simp)]
theorem comap_id (S : Submonoid P) : S.comap (MonoidHom.id P) = S 
goal: Submonoid.comap (MonoidHom.id P) S = S

full_name: AddSubmonoid.comap_id
code: @[to_additive (attr := simp)]
theorem comap_id (S : Submonoid P) : S.comap (MonoidHom.id P) = S 
goal: AddSubmonoid.comap (AddMonoidHom.id P) S = S

full_name: AddSubmonoid.map
code: /-- The image of a submonoid along a monoid homomorphism is a submonoid. -/
@[to_additive
      "The image of an `AddSubmonoid` along an `AddMonoid` homomorphism is an `AddSubmonoid`."]
def map (f : F) (S : Submonoid M) :
    Submonoid N 
goal: AddSubmonoid N

full_name: Submonoid.map
code: /-- The image of a submonoid along a monoid homomorphism is a submonoid. -/
@[to_additive
      "The image of an `AddSubmonoid` along an `AddMonoid` homomorphism is an `AddSubmonoid`."]
def map (f : F) (S : Submonoid M) :
    Submonoid N 
goal: Submonoid N

full_name: AddSubmonoid.coe_map
code: @[to_additive (attr := simp)]
theorem coe_map (f : F) (S : Submonoid M) : (S.map f : Set N) = f '' S 
goal: ↑(AddSubmonoid.map f S) = ⇑f '' ↑S

full_name: Submonoid.coe_map
code: @[to_additive (attr := simp)]
theorem coe_map (f : F) (S : Submonoid M) : (S.map f : Set N) = f '' S 
goal: ↑(Submonoid.map f S) = ⇑f '' ↑S

full_name: Submonoid.mem_map
code: @[to_additive (attr := simp)]
theorem mem_map {f : F} {S : Submonoid M} {y : N} : y ∈ S.map f ↔ ∃ x ∈ S, f x = y 
goal: y ∈ Submonoid.map f S ↔ ∃ x ∈ S, f x = y

full_name: AddSubmonoid.mem_map
code: @[to_additive (attr := simp)]
theorem mem_map {f : F} {S : Submonoid M} {y : N} : y ∈ S.map f ↔ ∃ x ∈ S, f x = y 
goal: y ∈ AddSubmonoid.map f S ↔ ∃ x ∈ S, f x = y

full_name: AddSubmonoid.mem_map_of_mem
code: @[to_additive]
theorem mem_map_of_mem (f : F) {S : Submonoid M} {x : M} (hx : x ∈ S) : f x ∈ S.map f 
goal: f x ∈ AddSubmonoid.map f S

full_name: Submonoid.mem_map_of_mem
code: @[to_additive]
theorem mem_map_of_mem (f : F) {S : Submonoid M} {x : M} (hx : x ∈ S) : f x ∈ S.map f 
goal: f x ∈ Submonoid.map f S

full_name: AddSubmonoid.apply_coe_mem_map
code: @[to_additive]
theorem apply_coe_mem_map (f : F) (S : Submonoid M) (x : S) : f x ∈ S.map f 
goal: f ↑x ∈ AddSubmonoid.map f S

full_name: Submonoid.apply_coe_mem_map
code: @[to_additive]
theorem apply_coe_mem_map (f : F) (S : Submonoid M) (x : S) : f x ∈ S.map f 
goal: f ↑x ∈ Submonoid.map f S

full_name: AddSubmonoid.map_map
code: @[to_additive]
theorem map_map (g : N →* P) (f : M →* N) : (S.map f).map g = S.map (g.comp f) 
goal: AddSubmonoid.map g (AddSubmonoid.map f S) = AddSubmonoid.map (g.comp f) S

full_name: Submonoid.map_map
code: @[to_additive]
theorem map_map (g : N →* P) (f : M →* N) : (S.map f).map g = S.map (g.comp f) 
goal: Submonoid.map g (Submonoid.map f S) = Submonoid.map (g.comp f) S

full_name: Submonoid.mem_map_iff_mem
code: @[to_additive (attr := simp 1100, nolint simpNF)]
theorem mem_map_iff_mem {f : F} (hf : Function.Injective f) {S : Submonoid M} {x : M} :
    f x ∈ S.map f ↔ x ∈ S 
goal: f x ∈ Submonoid.map f S ↔ x ∈ S

full_name: AddSubmonoid.mem_map_iff_mem
code: @[to_additive (attr := simp 1100, nolint simpNF)]
theorem mem_map_iff_mem {f : F} (hf : Function.Injective f) {S : Submonoid M} {x : M} :
    f x ∈ S.map f ↔ x ∈ S 
goal: f x ∈ AddSubmonoid.map f S ↔ x ∈ S

full_name: AddSubmonoid.map_le_iff_le_comap
code: @[to_additive]
theorem map_le_iff_le_comap {f : F} {S : Submonoid M} {T : Submonoid N} :
    S.map f ≤ T ↔ S ≤ T.comap f 
goal: AddSubmonoid.map f S ≤ T ↔ S ≤ AddSubmonoid.comap f T

full_name: Submonoid.map_le_iff_le_comap
code: @[to_additive]
theorem map_le_iff_le_comap {f : F} {S : Submonoid M} {T : Submonoid N} :
    S.map f ≤ T ↔ S ≤ T.comap f 
goal: Submonoid.map f S ≤ T ↔ S ≤ Submonoid.comap f T

full_name: Submonoid.gc_map_comap
code: @[to_additive]
theorem gc_map_comap (f : F) : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (Submonoid.map f) (Submonoid.comap f)

full_name: AddSubmonoid.gc_map_comap
code: @[to_additive]
theorem gc_map_comap (f : F) : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (AddSubmonoid.map f) (AddSubmonoid.comap f)

full_name: Submonoid.map_le_of_le_comap
code: @[to_additive]
theorem map_le_of_le_comap {T : Submonoid N} {f : F} : S ≤ T.comap f → S.map f ≤ T 
goal: S ≤ Submonoid.comap f T → Submonoid.map f S ≤ T

full_name: AddSubmonoid.map_le_of_le_comap
code: @[to_additive]
theorem map_le_of_le_comap {T : Submonoid N} {f : F} : S ≤ T.comap f → S.map f ≤ T 
goal: S ≤ AddSubmonoid.comap f T → AddSubmonoid.map f S ≤ T

full_name: AddSubmonoid.le_comap_of_map_le
code: @[to_additive]
theorem le_comap_of_map_le {T : Submonoid N} {f : F} : S.map f ≤ T → S ≤ T.comap f 
goal: AddSubmonoid.map f S ≤ T → S ≤ AddSubmonoid.comap f T

full_name: Submonoid.le_comap_of_map_le
code: @[to_additive]
theorem le_comap_of_map_le {T : Submonoid N} {f : F} : S.map f ≤ T → S ≤ T.comap f 
goal: Submonoid.map f S ≤ T → S ≤ Submonoid.comap f T

full_name: Submonoid.le_comap_map
code: @[to_additive]
theorem le_comap_map {f : F} : S ≤ (S.map f).comap f 
goal: S ≤ Submonoid.comap f (Submonoid.map f S)

full_name: AddSubmonoid.le_comap_map
code: @[to_additive]
theorem le_comap_map {f : F} : S ≤ (S.map f).comap f 
goal: S ≤ AddSubmonoid.comap f (AddSubmonoid.map f S)

full_name: AddSubmonoid.map_comap_le
code: @[to_additive]
theorem map_comap_le {S : Submonoid N} {f : F} : (S.comap f).map f ≤ S 
goal: AddSubmonoid.map f (AddSubmonoid.comap f S) ≤ S

full_name: Submonoid.map_comap_le
code: @[to_additive]
theorem map_comap_le {S : Submonoid N} {f : F} : (S.comap f).map f ≤ S 
goal: Submonoid.map f (Submonoid.comap f S) ≤ S

full_name: AddSubmonoid.monotone_map
code: @[to_additive]
theorem monotone_map {f : F} : Monotone (map f) 
goal: Monotone (AddSubmonoid.map f)

full_name: Submonoid.monotone_map
code: @[to_additive]
theorem monotone_map {f : F} : Monotone (map f) 
goal: Monotone (Submonoid.map f)

full_name: AddSubmonoid.monotone_comap
code: @[to_additive]
theorem monotone_comap {f : F} : Monotone (comap f) 
goal: Monotone (AddSubmonoid.comap f)

full_name: Submonoid.monotone_comap
code: @[to_additive]
theorem monotone_comap {f : F} : Monotone (comap f) 
goal: Monotone (Submonoid.comap f)

full_name: AddSubmonoid.map_comap_map
code: @[to_additive (attr := simp)]
theorem map_comap_map {f : F} : ((S.map f).comap f).map f = S.map f 
goal: AddSubmonoid.map f (AddSubmonoid.comap f (AddSubmonoid.map f S)) = AddSubmonoid.map f S

full_name: Submonoid.map_comap_map
code: @[to_additive (attr := simp)]
theorem map_comap_map {f : F} : ((S.map f).comap f).map f = S.map f 
goal: Submonoid.map f (Submonoid.comap f (Submonoid.map f S)) = Submonoid.map f S

full_name: Submonoid.comap_map_comap
code: @[to_additive (attr := simp)]
theorem comap_map_comap {S : Submonoid N} {f : F} : ((S.comap f).map f).comap f = S.comap f 
goal: Submonoid.comap f (Submonoid.map f (Submonoid.comap f S)) = Submonoid.comap f S

full_name: AddSubmonoid.comap_map_comap
code: @[to_additive (attr := simp)]
theorem comap_map_comap {S : Submonoid N} {f : F} : ((S.comap f).map f).comap f = S.comap f 
goal: AddSubmonoid.comap f (AddSubmonoid.map f (AddSubmonoid.comap f S)) = AddSubmonoid.comap f S

full_name: Submonoid.map_sup
code: @[to_additive]
theorem map_sup (S T : Submonoid M) (f : F) : (S ⊔ T).map f = S.map f ⊔ T.map f 
goal: Submonoid.map f (S ⊔ T) = Submonoid.map f S ⊔ Submonoid.map f T

full_name: AddSubmonoid.map_sup
code: @[to_additive]
theorem map_sup (S T : Submonoid M) (f : F) : (S ⊔ T).map f = S.map f ⊔ T.map f 
goal: AddSubmonoid.map f (S ⊔ T) = AddSubmonoid.map f S ⊔ AddSubmonoid.map f T

full_name: Submonoid.map_iSup
code: @[to_additive]
theorem map_iSup {ι : Sort*} (f : F) (s : ι → Submonoid M) : (iSup s).map f = ⨆ i, (s i).map f 
goal: Submonoid.map f (iSup s) = ⨆ i, Submonoid.map f (s i)

full_name: AddSubmonoid.map_iSup
code: @[to_additive]
theorem map_iSup {ι : Sort*} (f : F) (s : ι → Submonoid M) : (iSup s).map f = ⨆ i, (s i).map f 
goal: AddSubmonoid.map f (iSup s) = ⨆ i, AddSubmonoid.map f (s i)

full_name: Submonoid.comap_inf
code: @[to_additive]
theorem comap_inf (S T : Submonoid N) (f : F) : (S ⊓ T).comap f = S.comap f ⊓ T.comap f 
goal: Submonoid.comap f (S ⊓ T) = Submonoid.comap f S ⊓ Submonoid.comap f T

full_name: AddSubmonoid.comap_inf
code: @[to_additive]
theorem comap_inf (S T : Submonoid N) (f : F) : (S ⊓ T).comap f = S.comap f ⊓ T.comap f 
goal: AddSubmonoid.comap f (S ⊓ T) = AddSubmonoid.comap f S ⊓ AddSubmonoid.comap f T

full_name: AddSubmonoid.comap_iInf
code: @[to_additive]
theorem comap_iInf {ι : Sort*} (f : F) (s : ι → Submonoid N) :
    (iInf s).comap f = ⨅ i, (s i).comap f 
goal: AddSubmonoid.comap f (iInf s) = ⨅ i, AddSubmonoid.comap f (s i)

full_name: Submonoid.comap_iInf
code: @[to_additive]
theorem comap_iInf {ι : Sort*} (f : F) (s : ι → Submonoid N) :
    (iInf s).comap f = ⨅ i, (s i).comap f 
goal: Submonoid.comap f (iInf s) = ⨅ i, Submonoid.comap f (s i)

full_name: Submonoid.map_bot
code: @[to_additive (attr := simp)]
theorem map_bot (f : F) : (⊥ : Submonoid M).map f = ⊥ 
goal: Submonoid.map f ⊥ = ⊥

full_name: AddSubmonoid.map_bot
code: @[to_additive (attr := simp)]
theorem map_bot (f : F) : (⊥ : Submonoid M).map f = ⊥ 
goal: AddSubmonoid.map f ⊥ = ⊥

full_name: AddSubmonoid.comap_top
code: @[to_additive (attr := simp)]
theorem comap_top (f : F) : (⊤ : Submonoid N).comap f = ⊤ 
goal: AddSubmonoid.comap f ⊤ = ⊤

full_name: Submonoid.comap_top
code: @[to_additive (attr := simp)]
theorem comap_top (f : F) : (⊤ : Submonoid N).comap f = ⊤ 
goal: Submonoid.comap f ⊤ = ⊤

full_name: AddSubmonoid.map_id
code: @[to_additive (attr := simp)]
theorem map_id (S : Submonoid M) : S.map (MonoidHom.id M) = S 
goal: AddSubmonoid.map (AddMonoidHom.id M) S = S

full_name: Submonoid.map_id
code: @[to_additive (attr := simp)]
theorem map_id (S : Submonoid M) : S.map (MonoidHom.id M) = S 
goal: Submonoid.map (MonoidHom.id M) S = S

full_name: Submonoid.gciMapComap
code: /-- `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. -/
@[to_additive " `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. "]
def gciMapComap (hf : Function.Injective f) : GaloisCoinsertion (map f) (comap f) 
goal: GaloisCoinsertion (Submonoid.map f) (Submonoid.comap f)

full_name: AddSubmonoid.gciMapComap
code: /-- `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. -/
@[to_additive " `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. "]
def gciMapComap (hf : Function.Injective f) : GaloisCoinsertion (map f) (comap f) 
goal: GaloisCoinsertion (AddSubmonoid.map f) (AddSubmonoid.comap f)

full_name: Submonoid.comap_map_eq_of_injective
code: @[to_additive]
theorem comap_map_eq_of_injective (S : Submonoid M) : (S.map f).comap f = S 
goal: Submonoid.comap f (Submonoid.map f S) = S

full_name: AddSubmonoid.comap_map_eq_of_injective
code: @[to_additive]
theorem comap_map_eq_of_injective (S : Submonoid M) : (S.map f).comap f = S 
goal: AddSubmonoid.comap f (AddSubmonoid.map f S) = S

full_name: Submonoid.comap_surjective_of_injective
code: @[to_additive]
theorem comap_surjective_of_injective : Function.Surjective (comap f) 
goal: Function.Surjective (Submonoid.comap f)

full_name: AddSubmonoid.comap_surjective_of_injective
code: @[to_additive]
theorem comap_surjective_of_injective : Function.Surjective (comap f) 
goal: Function.Surjective (AddSubmonoid.comap f)

full_name: AddSubmonoid.map_injective_of_injective
code: @[to_additive]
theorem map_injective_of_injective : Function.Injective (map f) 
goal: Function.Injective (AddSubmonoid.map f)

full_name: Submonoid.map_injective_of_injective
code: @[to_additive]
theorem map_injective_of_injective : Function.Injective (map f) 
goal: Function.Injective (Submonoid.map f)

full_name: Submonoid.comap_inf_map_of_injective
code: @[to_additive]
theorem comap_inf_map_of_injective (S T : Submonoid M) : (S.map f ⊓ T.map f).comap f = S ⊓ T 
goal: Submonoid.comap f (Submonoid.map f S ⊓ Submonoid.map f T) = S ⊓ T

full_name: AddSubmonoid.comap_inf_map_of_injective
code: @[to_additive]
theorem comap_inf_map_of_injective (S T : Submonoid M) : (S.map f ⊓ T.map f).comap f = S ⊓ T 
goal: AddSubmonoid.comap f (AddSubmonoid.map f S ⊓ AddSubmonoid.map f T) = S ⊓ T

full_name: Submonoid.comap_iInf_map_of_injective
code: @[to_additive]
theorem comap_iInf_map_of_injective (S : ι → Submonoid M) : (⨅ i, (S i).map f).comap f = iInf S 
goal: Submonoid.comap f (⨅ i, Submonoid.map f (S i)) = iInf S

full_name: AddSubmonoid.comap_iInf_map_of_injective
code: @[to_additive]
theorem comap_iInf_map_of_injective (S : ι → Submonoid M) : (⨅ i, (S i).map f).comap f = iInf S 
goal: AddSubmonoid.comap f (⨅ i, AddSubmonoid.map f (S i)) = iInf S

full_name: Submonoid.comap_sup_map_of_injective
code: @[to_additive]
theorem comap_sup_map_of_injective (S T : Submonoid M) : (S.map f ⊔ T.map f).comap f = S ⊔ T 
goal: Submonoid.comap f (Submonoid.map f S ⊔ Submonoid.map f T) = S ⊔ T

full_name: AddSubmonoid.comap_sup_map_of_injective
code: @[to_additive]
theorem comap_sup_map_of_injective (S T : Submonoid M) : (S.map f ⊔ T.map f).comap f = S ⊔ T 
goal: AddSubmonoid.comap f (AddSubmonoid.map f S ⊔ AddSubmonoid.map f T) = S ⊔ T

full_name: AddSubmonoid.comap_iSup_map_of_injective
code: @[to_additive]
theorem comap_iSup_map_of_injective (S : ι → Submonoid M) : (⨆ i, (S i).map f).comap f = iSup S 
goal: AddSubmonoid.comap f (⨆ i, AddSubmonoid.map f (S i)) = iSup S

full_name: Submonoid.comap_iSup_map_of_injective
code: @[to_additive]
theorem comap_iSup_map_of_injective (S : ι → Submonoid M) : (⨆ i, (S i).map f).comap f = iSup S 
goal: Submonoid.comap f (⨆ i, Submonoid.map f (S i)) = iSup S

full_name: Submonoid.map_le_map_iff_of_injective
code: @[to_additive]
theorem map_le_map_iff_of_injective {S T : Submonoid M} : S.map f ≤ T.map f ↔ S ≤ T 
goal: Submonoid.map f S ≤ Submonoid.map f T ↔ S ≤ T

full_name: AddSubmonoid.map_le_map_iff_of_injective
code: @[to_additive]
theorem map_le_map_iff_of_injective {S T : Submonoid M} : S.map f ≤ T.map f ↔ S ≤ T 
goal: AddSubmonoid.map f S ≤ AddSubmonoid.map f T ↔ S ≤ T

full_name: Submonoid.map_strictMono_of_injective
code: @[to_additive]
theorem map_strictMono_of_injective : StrictMono (map f) 
goal: StrictMono (Submonoid.map f)

full_name: AddSubmonoid.map_strictMono_of_injective
code: @[to_additive]
theorem map_strictMono_of_injective : StrictMono (map f) 
goal: StrictMono (AddSubmonoid.map f)

full_name: AddSubmonoid.giMapComap
code: /-- `map f` and `comap f` form a `GaloisInsertion` when `f` is surjective. -/
@[to_additive " `map f` and `comap f` form a `GaloisInsertion` when `f` is surjective. "]
def giMapComap : GaloisInsertion (map f) (comap f) 
goal: GaloisInsertion (AddSubmonoid.map f) (AddSubmonoid.comap f)

full_name: Submonoid.giMapComap
code: /-- `map f` and `comap f` form a `GaloisInsertion` when `f` is surjective. -/
@[to_additive " `map f` and `comap f` form a `GaloisInsertion` when `f` is surjective. "]
def giMapComap : GaloisInsertion (map f) (comap f) 
goal: GaloisInsertion (Submonoid.map f) (Submonoid.comap f)

full_name: Submonoid.map_comap_eq_of_surjective
code: @[to_additive]
theorem map_comap_eq_of_surjective (S : Submonoid N) : (S.comap f).map f = S 
goal: Submonoid.map f (Submonoid.comap f S) = S

full_name: AddSubmonoid.map_comap_eq_of_surjective
code: @[to_additive]
theorem map_comap_eq_of_surjective (S : Submonoid N) : (S.comap f).map f = S 
goal: AddSubmonoid.map f (AddSubmonoid.comap f S) = S

full_name: AddSubmonoid.map_surjective_of_surjective
code: @[to_additive]
theorem map_surjective_of_surjective : Function.Surjective (map f) 
goal: Function.Surjective (AddSubmonoid.map f)

full_name: Submonoid.map_surjective_of_surjective
code: @[to_additive]
theorem map_surjective_of_surjective : Function.Surjective (map f) 
goal: Function.Surjective (Submonoid.map f)

full_name: Submonoid.comap_injective_of_surjective
code: @[to_additive]
theorem comap_injective_of_surjective : Function.Injective (comap f) 
goal: Function.Injective (Submonoid.comap f)

full_name: AddSubmonoid.comap_injective_of_surjective
code: @[to_additive]
theorem comap_injective_of_surjective : Function.Injective (comap f) 
goal: Function.Injective (AddSubmonoid.comap f)

full_name: AddSubmonoid.map_inf_comap_of_surjective
code: @[to_additive]
theorem map_inf_comap_of_surjective (S T : Submonoid N) : (S.comap f ⊓ T.comap f).map f = S ⊓ T 
goal: AddSubmonoid.map f (AddSubmonoid.comap f S ⊓ AddSubmonoid.comap f T) = S ⊓ T

full_name: Submonoid.map_inf_comap_of_surjective
code: @[to_additive]
theorem map_inf_comap_of_surjective (S T : Submonoid N) : (S.comap f ⊓ T.comap f).map f = S ⊓ T 
goal: Submonoid.map f (Submonoid.comap f S ⊓ Submonoid.comap f T) = S ⊓ T

full_name: Submonoid.map_iInf_comap_of_surjective
code: @[to_additive]
theorem map_iInf_comap_of_surjective (S : ι → Submonoid N) : (⨅ i, (S i).comap f).map f = iInf S 
goal: Submonoid.map f (⨅ i, Submonoid.comap f (S i)) = iInf S

full_name: AddSubmonoid.map_iInf_comap_of_surjective
code: @[to_additive]
theorem map_iInf_comap_of_surjective (S : ι → Submonoid N) : (⨅ i, (S i).comap f).map f = iInf S 
goal: AddSubmonoid.map f (⨅ i, AddSubmonoid.comap f (S i)) = iInf S

full_name: AddSubmonoid.map_sup_comap_of_surjective
code: @[to_additive]
theorem map_sup_comap_of_surjective (S T : Submonoid N) : (S.comap f ⊔ T.comap f).map f = S ⊔ T 
goal: AddSubmonoid.map f (AddSubmonoid.comap f S ⊔ AddSubmonoid.comap f T) = S ⊔ T

full_name: Submonoid.map_sup_comap_of_surjective
code: @[to_additive]
theorem map_sup_comap_of_surjective (S T : Submonoid N) : (S.comap f ⊔ T.comap f).map f = S ⊔ T 
goal: Submonoid.map f (Submonoid.comap f S ⊔ Submonoid.comap f T) = S ⊔ T

full_name: Submonoid.map_iSup_comap_of_surjective
code: @[to_additive]
theorem map_iSup_comap_of_surjective (S : ι → Submonoid N) : (⨆ i, (S i).comap f).map f = iSup S 
goal: Submonoid.map f (⨆ i, Submonoid.comap f (S i)) = iSup S

full_name: AddSubmonoid.map_iSup_comap_of_surjective
code: @[to_additive]
theorem map_iSup_comap_of_surjective (S : ι → Submonoid N) : (⨆ i, (S i).comap f).map f = iSup S 
goal: AddSubmonoid.map f (⨆ i, AddSubmonoid.comap f (S i)) = iSup S

full_name: Submonoid.comap_le_comap_iff_of_surjective
code: @[to_additive]
theorem comap_le_comap_iff_of_surjective {S T : Submonoid N} : S.comap f ≤ T.comap f ↔ S ≤ T 
goal: Submonoid.comap f S ≤ Submonoid.comap f T ↔ S ≤ T

full_name: AddSubmonoid.comap_le_comap_iff_of_surjective
code: @[to_additive]
theorem comap_le_comap_iff_of_surjective {S T : Submonoid N} : S.comap f ≤ T.comap f ↔ S ≤ T 
goal: AddSubmonoid.comap f S ≤ AddSubmonoid.comap f T ↔ S ≤ T

full_name: Submonoid.comap_strictMono_of_surjective
code: @[to_additive]
theorem comap_strictMono_of_surjective : StrictMono (comap f) 
goal: StrictMono (Submonoid.comap f)

full_name: AddSubmonoid.comap_strictMono_of_surjective
code: @[to_additive]
theorem comap_strictMono_of_surjective : StrictMono (comap f) 
goal: StrictMono (AddSubmonoid.comap f)

full_name: ZeroMemClass.zero
code: /-- A submonoid of a monoid inherits a 1. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits a zero."]
instance one : One S' 
goal: Zero ↥S'

full_name: OneMemClass.one
code: /-- A submonoid of a monoid inherits a 1. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits a zero."]
instance one : One S' 
goal: One ↥S'

full_name: ZeroMemClass.coe_zero
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : S') : M₁) = 1 
goal: ↑0 = 0

full_name: OneMemClass.coe_one
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : S') : M₁) = 1 
goal: ↑1 = 1

full_name: ZeroMemClass.coe_eq_zero
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_eq_one {x : S'} : (↑x : M₁) = 1 ↔ x = 1 
goal: ↑x = 0 ↔ x = 0

full_name: OneMemClass.coe_eq_one
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_eq_one {x : S'} : (↑x : M₁) = 1 ↔ x = 1 
goal: ↑x = 1 ↔ x = 1

full_name: ZeroMemClass.zero_def
code: @[to_additive]
theorem one_def : (1 : S') = ⟨1, OneMemClass.one_mem S'⟩ 
goal: 0 = ⟨0, ⋯⟩

full_name: OneMemClass.one_def
code: @[to_additive]
theorem one_def : (1 : S') = ⟨1, OneMemClass.one_mem S'⟩ 
goal: 1 = ⟨1, ⋯⟩

full_name: AddSubmonoidClass.nSMul
code: /-- An `AddSubmonoid` of an `AddMonoid` inherits a scalar multiplication. -/
instance AddSubmonoidClass.nSMul {M} [AddMonoid M] {A : Type*} [SetLike A M]
    [AddSubmonoidClass A M] (S : A) : SMul ℕ S 
goal: SMul ℕ ↥S

full_name: SubmonoidClass.nPow
code: /-- A submonoid of a monoid inherits a power operator. -/
instance nPow {M} [Monoid M] {A : Type*} [SetLike A M] [SubmonoidClass A M] (S : A) : Pow S ℕ 
goal: Pow ↥S ℕ

full_name: AddSubmonoidClass.coe_nsmul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow {M} [Monoid M] {A : Type*} [SetLike A M] [SubmonoidClass A M] {S : A} (x : S)
    (n : ℕ) : ↑(x ^ n) = (x : M) ^ n 
goal: ↑(n • x) = n • ↑x

full_name: SubmonoidClass.coe_pow
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow {M} [Monoid M] {A : Type*} [SetLike A M] [SubmonoidClass A M] {S : A} (x : S)
    (n : ℕ) : ↑(x ^ n) = (x : M) ^ n 
goal: ↑(x ^ n) = ↑x ^ n

full_name: SubmonoidClass.mk_pow
code: @[to_additive (attr := simp)]
theorem mk_pow {M} [Monoid M] {A : Type*} [SetLike A M] [SubmonoidClass A M] {S : A} (x : M)
    (hx : x ∈ S) (n : ℕ) : (⟨x, hx⟩ : S) ^ n = ⟨x ^ n, pow_mem hx n⟩ 
goal: ⟨x, hx⟩ ^ n = ⟨x ^ n, ⋯⟩

full_name: AddSubmonoidClass.mk_nsmul
code: @[to_additive (attr := simp)]
theorem mk_pow {M} [Monoid M] {A : Type*} [SetLike A M] [SubmonoidClass A M] {S : A} (x : M)
    (hx : x ∈ S) (n : ℕ) : (⟨x, hx⟩ : S) ^ n = ⟨x ^ n, pow_mem hx n⟩ 
goal: n • ⟨x, hx⟩ = ⟨n • x, ⋯⟩

full_name: SubmonoidClass.toMulOneClass
code: /-- A submonoid of a unital magma inherits a unital magma structure. -/
@[to_additive
      "An `AddSubmonoid` of a unital additive magma inherits a unital additive magma structure."]
instance (priority := 75) toMulOneClass {M : Type*} [MulOneClass M] {A : Type*} [SetLike A M]
    [SubmonoidClass A M] (S : A) : MulOneClass S 
goal: MulOneClass ↥S

full_name: AddSubmonoidClass.toAddZeroClass
code: /-- A submonoid of a unital magma inherits a unital magma structure. -/
@[to_additive
      "An `AddSubmonoid` of a unital additive magma inherits a unital additive magma structure."]
instance (priority := 75) toMulOneClass {M : Type*} [MulOneClass M] {A : Type*} [SetLike A M]
    [SubmonoidClass A M] (S : A) : MulOneClass S 
goal: AddZeroClass ↥S

full_name: AddSubmonoidClass.toAddMonoid
code: /-- A submonoid of a monoid inherits a monoid structure. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits an `AddMonoid` structure."]
instance (priority := 75) toMonoid {M : Type*} [Monoid M] {A : Type*} [SetLike A M]
    [SubmonoidClass A M] (S : A) : Monoid S 
goal: AddMonoid ↥S

full_name: SubmonoidClass.toMonoid
code: /-- A submonoid of a monoid inherits a monoid structure. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits an `AddMonoid` structure."]
instance (priority := 75) toMonoid {M : Type*} [Monoid M] {A : Type*} [SetLike A M]
    [SubmonoidClass A M] (S : A) : Monoid S 
goal: Monoid ↥S

full_name: SubmonoidClass.toCommMonoid
code: /-- A submonoid of a `CommMonoid` is a `CommMonoid`. -/
@[to_additive "An `AddSubmonoid` of an `AddCommMonoid` is an `AddCommMonoid`."]
instance (priority := 75) toCommMonoid {M} [CommMonoid M] {A : Type*} [SetLike A M]
    [SubmonoidClass A M] (S : A) : CommMonoid S 
goal: CommMonoid ↥S

full_name: AddSubmonoidClass.toAddCommMonoid
code: /-- A submonoid of a `CommMonoid` is a `CommMonoid`. -/
@[to_additive "An `AddSubmonoid` of an `AddCommMonoid` is an `AddCommMonoid`."]
instance (priority := 75) toCommMonoid {M} [CommMonoid M] {A : Type*} [SetLike A M]
    [SubmonoidClass A M] (S : A) : CommMonoid S 
goal: AddCommMonoid ↥S

full_name: AddSubmonoidClass.subtype
code: /-- The natural monoid hom from a submonoid of monoid `M` to `M`. -/
@[to_additive "The natural monoid hom from an `AddSubmonoid` of `AddMonoid` `M` to `M`."]
def subtype : S' →* M 
goal: ↥S' →+ M

full_name: SubmonoidClass.subtype
code: /-- The natural monoid hom from a submonoid of monoid `M` to `M`. -/
@[to_additive "The natural monoid hom from an `AddSubmonoid` of `AddMonoid` `M` to `M`."]
def subtype : S' →* M 
goal: ↥S' →* M

full_name: SubmonoidClass.coe_subtype
code: @[to_additive (attr := simp)]
theorem coe_subtype : (SubmonoidClass.subtype S' : S' → M) = Subtype.val 
goal: ⇑(SubmonoidClass.subtype S') = Subtype.val

full_name: AddSubmonoidClass.coe_subtype
code: @[to_additive (attr := simp)]
theorem coe_subtype : (SubmonoidClass.subtype S' : S' → M) = Subtype.val 
goal: ⇑(AddSubmonoidClass.subtype S') = Subtype.val

full_name: Submonoid.mul
code: /-- A submonoid of a monoid inherits a multiplication. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits an addition."]
instance mul : Mul S 
goal: Mul ↥S

full_name: AddSubmonoid.add
code: /-- A submonoid of a monoid inherits a multiplication. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits an addition."]
instance mul : Mul S 
goal: Add ↥S

full_name: Submonoid.one
code: /-- A submonoid of a monoid inherits a 1. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits a zero."]
instance one : One S 
goal: One ↥S

full_name: AddSubmonoid.zero
code: /-- A submonoid of a monoid inherits a 1. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits a zero."]
instance one : One S 
goal: Zero ↥S

full_name: AddSubmonoid.coe_add
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul (x y : S) : (↑(x * y) : M) = ↑x * ↑y 
goal: ↑(x + y) = ↑x + ↑y

full_name: Submonoid.coe_mul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul (x y : S) : (↑(x * y) : M) = ↑x * ↑y 
goal: ↑(x * y) = ↑x * ↑y

full_name: AddSubmonoid.coe_zero
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : S) : M) = 1 
goal: ↑0 = 0

full_name: Submonoid.coe_one
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : S) : M) = 1 
goal: ↑1 = 1

full_name: Submonoid.mk_eq_one
code: @[to_additive (attr := simp)]
lemma mk_eq_one {a : M} {ha} : (⟨a, ha⟩ : S) = 1 ↔ a = 1 
goal: ⟨a, ha⟩ = 1 ↔ a = 1

full_name: AddSubmonoid.mk_eq_zero
code: @[to_additive (attr := simp)]
lemma mk_eq_one {a : M} {ha} : (⟨a, ha⟩ : S) = 1 ↔ a = 1 
goal: ⟨a, ha⟩ = 0 ↔ a = 0

full_name: AddSubmonoid.mk_add_mk
code: @[to_additive (attr := simp)]
theorem mk_mul_mk (x y : M) (hx : x ∈ S) (hy : y ∈ S) :
    (⟨x, hx⟩ : S) * ⟨y, hy⟩ = ⟨x * y, S.mul_mem hx hy⟩ 
goal: ⟨x, hx⟩ + ⟨y, hy⟩ = ⟨x + y, ⋯⟩

full_name: Submonoid.mk_mul_mk
code: @[to_additive (attr := simp)]
theorem mk_mul_mk (x y : M) (hx : x ∈ S) (hy : y ∈ S) :
    (⟨x, hx⟩ : S) * ⟨y, hy⟩ = ⟨x * y, S.mul_mem hx hy⟩ 
goal: ⟨x, hx⟩ * ⟨y, hy⟩ = ⟨x * y, ⋯⟩

full_name: AddSubmonoid.add_def
code: @[to_additive]
theorem mul_def (x y : S) : x * y = ⟨x * y, S.mul_mem x.2 y.2⟩ 
goal: x + y = ⟨↑x + ↑y, ⋯⟩

full_name: Submonoid.mul_def
code: @[to_additive]
theorem mul_def (x y : S) : x * y = ⟨x * y, S.mul_mem x.2 y.2⟩ 
goal: x * y = ⟨↑x * ↑y, ⋯⟩

full_name: Submonoid.one_def
code: @[to_additive]
theorem one_def : (1 : S) = ⟨1, S.one_mem⟩ 
goal: 1 = ⟨1, ⋯⟩

full_name: AddSubmonoid.zero_def
code: @[to_additive]
theorem one_def : (1 : S) = ⟨1, S.one_mem⟩ 
goal: 0 = ⟨0, ⋯⟩

full_name: Submonoid.toMulOneClass
code: /-- A submonoid of a unital magma inherits a unital magma structure. -/
@[to_additive
      "An `AddSubmonoid` of a unital additive magma inherits a unital additive magma structure."]
instance toMulOneClass {M : Type*} [MulOneClass M] (S : Submonoid M) : MulOneClass S 
goal: MulOneClass ↥S

full_name: AddSubmonoid.toAddZeroClass
code: /-- A submonoid of a unital magma inherits a unital magma structure. -/
@[to_additive
      "An `AddSubmonoid` of a unital additive magma inherits a unital additive magma structure."]
instance toMulOneClass {M : Type*} [MulOneClass M] (S : Submonoid M) : MulOneClass S 
goal: AddZeroClass ↥S

full_name: Submonoid.pow_mem
code: @[to_additive]
protected theorem pow_mem {M : Type*} [Monoid M] (S : Submonoid M) {x : M} (hx : x ∈ S) (n : ℕ) :
    x ^ n ∈ S 
goal: x ^ n ∈ S

full_name: AddSubmonoid.nsmul_mem
code: @[to_additive]
protected theorem pow_mem {M : Type*} [Monoid M] (S : Submonoid M) {x : M} (hx : x ∈ S) (n : ℕ) :
    x ^ n ∈ S 
goal: n • x ∈ S

full_name: AddSubmonoid.toAddMonoid
code: /-- A submonoid of a monoid inherits a monoid structure. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits an `AddMonoid` structure."]
instance toMonoid {M : Type*} [Monoid M] (S : Submonoid M) : Monoid S 
goal: AddMonoid ↥S

full_name: Submonoid.toMonoid
code: /-- A submonoid of a monoid inherits a monoid structure. -/
@[to_additive "An `AddSubmonoid` of an `AddMonoid` inherits an `AddMonoid` structure."]
instance toMonoid {M : Type*} [Monoid M] (S : Submonoid M) : Monoid S 
goal: Monoid ↥S

full_name: AddSubmonoid.toAddCommMonoid
code: /-- A submonoid of a `CommMonoid` is a `CommMonoid`. -/
@[to_additive "An `AddSubmonoid` of an `AddCommMonoid` is an `AddCommMonoid`."]
instance toCommMonoid {M} [CommMonoid M] (S : Submonoid M) : CommMonoid S 
goal: AddCommMonoid ↥S

full_name: Submonoid.toCommMonoid
code: /-- A submonoid of a `CommMonoid` is a `CommMonoid`. -/
@[to_additive "An `AddSubmonoid` of an `AddCommMonoid` is an `AddCommMonoid`."]
instance toCommMonoid {M} [CommMonoid M] (S : Submonoid M) : CommMonoid S 
goal: CommMonoid ↥S

full_name: AddSubmonoid.subtype
code: /-- The natural monoid hom from a submonoid of monoid `M` to `M`. -/
@[to_additive "The natural monoid hom from an `AddSubmonoid` of `AddMonoid` `M` to `M`."]
def subtype : S →* M 
goal: ↥S →+ M

full_name: Submonoid.subtype
code: /-- The natural monoid hom from a submonoid of monoid `M` to `M`. -/
@[to_additive "The natural monoid hom from an `AddSubmonoid` of `AddMonoid` `M` to `M`."]
def subtype : S →* M 
goal: ↥S →* M

full_name: AddSubmonoid.coe_subtype
code: @[to_additive (attr := simp)]
theorem coe_subtype : ⇑S.subtype = Subtype.val 
goal: ⇑S.subtype = Subtype.val

full_name: Submonoid.coe_subtype
code: @[to_additive (attr := simp)]
theorem coe_subtype : ⇑S.subtype = Subtype.val 
goal: ⇑S.subtype = Subtype.val

full_name: AddSubmonoid.topEquiv
code: /-- The top submonoid is isomorphic to the monoid. -/
@[to_additive (attr := simps) "The top additive submonoid is isomorphic to the additive monoid."]
def topEquiv : (⊤ : Submonoid M) ≃* M 
goal: ↥⊤ ≃+ M

full_name: AddSubmonoid.topEquiv_symm_apply_coe
code: /-- The top submonoid is isomorphic to the monoid. -/
@[to_additive (attr := simps) "The top additive submonoid is isomorphic to the additive monoid."]
def topEquiv : (⊤ : Submonoid M) ≃* M 
goal: ↑(AddSubmonoid.topEquiv.symm x) = x

full_name: AddSubmonoid.topEquiv_apply
code: /-- The top submonoid is isomorphic to the monoid. -/
@[to_additive (attr := simps) "The top additive submonoid is isomorphic to the additive monoid."]
def topEquiv : (⊤ : Submonoid M) ≃* M 
goal: AddSubmonoid.topEquiv x = ↑x

full_name: Submonoid.topEquiv_symm_apply_coe
code: /-- The top submonoid is isomorphic to the monoid. -/
@[to_additive (attr := simps) "The top additive submonoid is isomorphic to the additive monoid."]
def topEquiv : (⊤ : Submonoid M) ≃* M 
goal: ↑(Submonoid.topEquiv.symm x) = x

full_name: Submonoid.topEquiv_apply
code: /-- The top submonoid is isomorphic to the monoid. -/
@[to_additive (attr := simps) "The top additive submonoid is isomorphic to the additive monoid."]
def topEquiv : (⊤ : Submonoid M) ≃* M 
goal: Submonoid.topEquiv x = ↑x

full_name: Submonoid.topEquiv
code: /-- The top submonoid is isomorphic to the monoid. -/
@[to_additive (attr := simps) "The top additive submonoid is isomorphic to the additive monoid."]
def topEquiv : (⊤ : Submonoid M) ≃* M 
goal: ↥⊤ ≃* M

full_name: Submonoid.topEquiv_toMonoidHom
code: @[to_additive (attr := simp)]
theorem topEquiv_toMonoidHom : ((topEquiv : _ ≃* M) : _ →* M) = (⊤ : Submonoid M).subtype 
goal: ↑Submonoid.topEquiv = ⊤.subtype

full_name: AddSubmonoid.topEquiv_toAddMonoidHom
code: @[to_additive (attr := simp)]
theorem topEquiv_toMonoidHom : ((topEquiv : _ ≃* M) : _ →* M) = (⊤ : Submonoid M).subtype 
goal: ↑AddSubmonoid.topEquiv = ⊤.subtype

full_name: AddSubmonoid.equivMapOfInjective
code: /-- A subgroup is isomorphic to its image under an injective function. If you have an isomorphism,
use `MulEquiv.submonoidMap` for better definitional equalities. -/
@[to_additive "An additive subgroup is isomorphic to its image under an injective function. If you
have an isomorphism, use `AddEquiv.addSubmonoidMap` for better definitional equalities."]
noncomputable def equivMapOfInjective (f : M →* N) (hf : Function.Injective f) : S ≃* S.map f 
goal: ↥S ≃+ ↥(AddSubmonoid.map f S)

full_name: Submonoid.equivMapOfInjective
code: /-- A subgroup is isomorphic to its image under an injective function. If you have an isomorphism,
use `MulEquiv.submonoidMap` for better definitional equalities. -/
@[to_additive "An additive subgroup is isomorphic to its image under an injective function. If you
have an isomorphism, use `AddEquiv.addSubmonoidMap` for better definitional equalities."]
noncomputable def equivMapOfInjective (f : M →* N) (hf : Function.Injective f) : S ≃* S.map f 
goal: ↥S ≃* ↥(Submonoid.map f S)

full_name: AddSubmonoid.coe_equivMapOfInjective_apply
code: @[to_additive (attr := simp)]
theorem coe_equivMapOfInjective_apply (f : M →* N) (hf : Function.Injective f) (x : S) :
    (equivMapOfInjective S f hf x : N) = f x 
goal: ↑((S.equivMapOfInjective f hf) x) = f ↑x

full_name: Submonoid.coe_equivMapOfInjective_apply
code: @[to_additive (attr := simp)]
theorem coe_equivMapOfInjective_apply (f : M →* N) (hf : Function.Injective f) (x : S) :
    (equivMapOfInjective S f hf x : N) = f x 
goal: ↑((S.equivMapOfInjective f hf) x) = f ↑x

full_name: Submonoid.closure_closure_coe_preimage
code: @[to_additive (attr := simp)]
theorem closure_closure_coe_preimage {s : Set M} : closure (((↑) : closure s → M) ⁻¹' s) = ⊤ 
goal: Submonoid.closure (Subtype.val ⁻¹' s) = ⊤

full_name: AddSubmonoid.closure_closure_coe_preimage
code: @[to_additive (attr := simp)]
theorem closure_closure_coe_preimage {s : Set M} : closure (((↑) : closure s → M) ⁻¹' s) = ⊤ 
goal: AddSubmonoid.closure (Subtype.val ⁻¹' s) = ⊤

full_name: Submonoid.prod
code: /-- Given submonoids `s`, `t` of monoids `M`, `N` respectively, `s × t` as a submonoid
of `M × N`. -/
@[to_additive prod
      "Given `AddSubmonoid`s `s`, `t` of `AddMonoid`s `A`, `B` respectively, `s × t`
      as an `AddSubmonoid` of `A × B`."]
def prod (s : Submonoid M) (t : Submonoid N) :
    Submonoid (M × N) 
goal: Submonoid (M × N)

full_name: AddSubmonoid.prod
code: /-- Given submonoids `s`, `t` of monoids `M`, `N` respectively, `s × t` as a submonoid
of `M × N`. -/
@[to_additive prod
      "Given `AddSubmonoid`s `s`, `t` of `AddMonoid`s `A`, `B` respectively, `s × t`
      as an `AddSubmonoid` of `A × B`."]
def prod (s : Submonoid M) (t : Submonoid N) :
    Submonoid (M × N) 
goal: AddSubmonoid (M × N)

full_name: AddSubmonoid.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (s : Submonoid M) (t : Submonoid N) :
    (s.prod t : Set (M × N)) = (s : Set M) ×ˢ (t : Set N) 
goal: ↑(s.prod t) = ↑s ×ˢ ↑t

full_name: Submonoid.coe_prod
code: @[to_additive coe_prod]
theorem coe_prod (s : Submonoid M) (t : Submonoid N) :
    (s.prod t : Set (M × N)) = (s : Set M) ×ˢ (t : Set N) 
goal: ↑(s.prod t) = ↑s ×ˢ ↑t

full_name: AddSubmonoid.mem_prod
code: @[to_additive mem_prod]
theorem mem_prod {s : Submonoid M} {t : Submonoid N} {p : M × N} :
    p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t 
goal: p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t

full_name: Submonoid.mem_prod
code: @[to_additive mem_prod]
theorem mem_prod {s : Submonoid M} {t : Submonoid N} {p : M × N} :
    p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t 
goal: p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t

full_name: AddSubmonoid.prod_mono
code: @[to_additive prod_mono]
theorem prod_mono {s₁ s₂ : Submonoid M} {t₁ t₂ : Submonoid N} (hs : s₁ ≤ s₂) (ht : t₁ ≤ t₂) :
    s₁.prod t₁ ≤ s₂.prod t₂ 
goal: s₁.prod t₁ ≤ s₂.prod t₂

full_name: Submonoid.prod_mono
code: @[to_additive prod_mono]
theorem prod_mono {s₁ s₂ : Submonoid M} {t₁ t₂ : Submonoid N} (hs : s₁ ≤ s₂) (ht : t₁ ≤ t₂) :
    s₁.prod t₁ ≤ s₂.prod t₂ 
goal: s₁.prod t₁ ≤ s₂.prod t₂

full_name: Submonoid.prod_top
code: @[to_additive prod_top]
theorem prod_top (s : Submonoid M) : s.prod (⊤ : Submonoid N) = s.comap (MonoidHom.fst M N) 
goal: s.prod ⊤ = Submonoid.comap (MonoidHom.fst M N) s

full_name: AddSubmonoid.prod_top
code: @[to_additive prod_top]
theorem prod_top (s : Submonoid M) : s.prod (⊤ : Submonoid N) = s.comap (MonoidHom.fst M N) 
goal: s.prod ⊤ = AddSubmonoid.comap (AddMonoidHom.fst M N) s

full_name: AddSubmonoid.top_prod
code: @[to_additive top_prod]
theorem top_prod (s : Submonoid N) : (⊤ : Submonoid M).prod s = s.comap (MonoidHom.snd M N) 
goal: ⊤.prod s = AddSubmonoid.comap (AddMonoidHom.snd M N) s

full_name: Submonoid.top_prod
code: @[to_additive top_prod]
theorem top_prod (s : Submonoid N) : (⊤ : Submonoid M).prod s = s.comap (MonoidHom.snd M N) 
goal: ⊤.prod s = Submonoid.comap (MonoidHom.snd M N) s

full_name: Submonoid.top_prod_top
code: @[to_additive (attr := simp) top_prod_top]
theorem top_prod_top : (⊤ : Submonoid M).prod (⊤ : Submonoid N) = ⊤ 
goal: ⊤.prod ⊤ = ⊤

full_name: AddSubmonoid.top_prod_top
code: @[to_additive (attr := simp) top_prod_top]
theorem top_prod_top : (⊤ : Submonoid M).prod (⊤ : Submonoid N) = ⊤ 
goal: ⊤.prod ⊤ = ⊤

full_name: Submonoid.bot_prod_bot
code: @[to_additive bot_prod_bot]
theorem bot_prod_bot : (⊥ : Submonoid M).prod (⊥ : Submonoid N) = ⊥ 
goal: ⊥.prod ⊥ = ⊥

full_name: AddSubmonoid.bot_prod_bot
code: @[to_additive bot_prod_bot]
theorem bot_prod_bot : (⊥ : Submonoid M).prod (⊥ : Submonoid N) = ⊥ 
goal: ⊥.prod ⊥ = ⊥

full_name: AddSubmonoid.prodEquiv
code: /-- The product of submonoids is isomorphic to their product as monoids. -/
@[to_additive prodEquiv
      "The product of additive submonoids is isomorphic to their product as additive monoids"]
def prodEquiv (s : Submonoid M) (t : Submonoid N) : s.prod t ≃* s × t 
goal: ↥(s.prod t) ≃+ ↥s × ↥t

full_name: Submonoid.prodEquiv
code: /-- The product of submonoids is isomorphic to their product as monoids. -/
@[to_additive prodEquiv
      "The product of additive submonoids is isomorphic to their product as additive monoids"]
def prodEquiv (s : Submonoid M) (t : Submonoid N) : s.prod t ≃* s × t 
goal: ↥(s.prod t) ≃* ↥s × ↥t

full_name: Submonoid.map_inl
code: @[to_additive]
theorem map_inl (s : Submonoid M) : s.map (inl M N) = s.prod ⊥ 
goal: Submonoid.map (MonoidHom.inl M N) s = s.prod ⊥

full_name: AddSubmonoid.map_inl
code: @[to_additive]
theorem map_inl (s : Submonoid M) : s.map (inl M N) = s.prod ⊥ 
goal: AddSubmonoid.map (AddMonoidHom.inl M N) s = s.prod ⊥

full_name: Submonoid.map_inr
code: @[to_additive]
theorem map_inr (s : Submonoid N) : s.map (inr M N) = prod ⊥ s 
goal: Submonoid.map (MonoidHom.inr M N) s = ⊥.prod s

full_name: AddSubmonoid.map_inr
code: @[to_additive]
theorem map_inr (s : Submonoid N) : s.map (inr M N) = prod ⊥ s 
goal: AddSubmonoid.map (AddMonoidHom.inr M N) s = ⊥.prod s

full_name: Submonoid.prod_bot_sup_bot_prod
code: @[to_additive (attr := simp) prod_bot_sup_bot_prod]
theorem prod_bot_sup_bot_prod (s : Submonoid M) (t : Submonoid N) :
    (prod s ⊥) ⊔ (prod ⊥ t) = prod s t 
goal: s.prod ⊥ ⊔ ⊥.prod t = s.prod t

full_name: AddSubmonoid.prod_bot_sup_bot_prod
code: @[to_additive (attr := simp) prod_bot_sup_bot_prod]
theorem prod_bot_sup_bot_prod (s : Submonoid M) (t : Submonoid N) :
    (prod s ⊥) ⊔ (prod ⊥ t) = prod s t 
goal: s.prod ⊥ ⊔ ⊥.prod t = s.prod t

full_name: Submonoid.mem_map_equiv
code: @[to_additive]
theorem mem_map_equiv {f : M ≃* N} {K : Submonoid M} {x : N} :
    x ∈ K.map f.toMonoidHom ↔ f.symm x ∈ K 
goal: x ∈ Submonoid.map f.toMonoidHom K ↔ f.symm x ∈ K

full_name: AddSubmonoid.mem_map_equiv
code: @[to_additive]
theorem mem_map_equiv {f : M ≃* N} {K : Submonoid M} {x : N} :
    x ∈ K.map f.toMonoidHom ↔ f.symm x ∈ K 
goal: x ∈ AddSubmonoid.map f.toAddMonoidHom K ↔ f.symm x ∈ K

full_name: AddSubmonoid.map_equiv_eq_comap_symm
code: @[to_additive]
theorem map_equiv_eq_comap_symm (f : M ≃* N) (K : Submonoid M) :
    K.map f.toMonoidHom = K.comap f.symm.toMonoidHom 
goal: AddSubmonoid.map f.toAddMonoidHom K = AddSubmonoid.comap f.symm.toAddMonoidHom K

full_name: Submonoid.map_equiv_eq_comap_symm
code: @[to_additive]
theorem map_equiv_eq_comap_symm (f : M ≃* N) (K : Submonoid M) :
    K.map f.toMonoidHom = K.comap f.symm.toMonoidHom 
goal: Submonoid.map f.toMonoidHom K = Submonoid.comap f.symm.toMonoidHom K

full_name: AddSubmonoid.comap_equiv_eq_map_symm
code: @[to_additive]
theorem comap_equiv_eq_map_symm (f : N ≃* M) (K : Submonoid M) :
    K.comap f = K.map f.symm 
goal: AddSubmonoid.comap f K = AddSubmonoid.map f.symm K

full_name: Submonoid.comap_equiv_eq_map_symm
code: @[to_additive]
theorem comap_equiv_eq_map_symm (f : N ≃* M) (K : Submonoid M) :
    K.comap f = K.map f.symm 
goal: Submonoid.comap f K = Submonoid.map f.symm K

full_name: Submonoid.map_equiv_top
code: @[to_additive (attr := simp)]
theorem map_equiv_top (f : M ≃* N) : (⊤ : Submonoid M).map f = ⊤ 
goal: Submonoid.map f ⊤ = ⊤

full_name: AddSubmonoid.map_equiv_top
code: @[to_additive (attr := simp)]
theorem map_equiv_top (f : M ≃* N) : (⊤ : Submonoid M).map f = ⊤ 
goal: AddSubmonoid.map f ⊤ = ⊤

full_name: Submonoid.le_prod_iff
code: @[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 
goal: u ≤ s.prod t ↔ Submonoid.map (MonoidHom.fst M N) u ≤ s ∧ Submonoid.map (MonoidHom.snd M N) u ≤ t

full_name: AddSubmonoid.le_prod_iff
code: @[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 
goal: u ≤ s.prod t ↔ AddSubmonoid.map (AddMonoidHom.fst M N) u ≤ s ∧ AddSubmonoid.map (AddMonoidHom.snd M N) u ≤ t

full_name: Submonoid.prod_le_iff
code: @[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 
goal: s.prod t ≤ u ↔ Submonoid.map (MonoidHom.inl M N) s ≤ u ∧ Submonoid.map (MonoidHom.inr M N) t ≤ u

full_name: AddSubmonoid.prod_le_iff
code: @[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 
goal: s.prod t ≤ u ↔ AddSubmonoid.map (AddMonoidHom.inl M N) s ≤ u ∧ AddSubmonoid.map (AddMonoidHom.inr M N) t ≤ u

full_name: AddMonoidHom.mrange
code: /-- The range of a monoid homomorphism is a submonoid. See Note [range copy pattern]. -/
@[to_additive "The range of an `AddMonoidHom` is an `AddSubmonoid`."]
def mrange (f : F) : Submonoid N 
goal: AddSubmonoid N

full_name: MonoidHom.mrange
code: /-- The range of a monoid homomorphism is a submonoid. See Note [range copy pattern]. -/
@[to_additive "The range of an `AddMonoidHom` is an `AddSubmonoid`."]
def mrange (f : F) : Submonoid N 
goal: Submonoid N

full_name: MonoidHom.coe_mrange
code: @[to_additive (attr := simp)]
theorem coe_mrange (f : F) : (mrange f : Set N) = Set.range f 
goal: ↑(MonoidHom.mrange f) = Set.range ⇑f

full_name: AddMonoidHom.coe_mrange
code: @[to_additive (attr := simp)]
theorem coe_mrange (f : F) : (mrange f : Set N) = Set.range f 
goal: ↑(AddMonoidHom.mrange f) = Set.range ⇑f

full_name: MonoidHom.mem_mrange
code: @[to_additive (attr := simp)]
theorem mem_mrange {f : F} {y : N} : y ∈ mrange f ↔ ∃ x, f x = y 
goal: y ∈ MonoidHom.mrange f ↔ ∃ x, f x = y

full_name: AddMonoidHom.mem_mrange
code: @[to_additive (attr := simp)]
theorem mem_mrange {f : F} {y : N} : y ∈ mrange f ↔ ∃ x, f x = y 
goal: y ∈ AddMonoidHom.mrange f ↔ ∃ x, f x = y

full_name: MonoidHom.mrange_eq_map
code: @[to_additive]
theorem mrange_eq_map (f : F) : mrange f = (⊤ : Submonoid M).map f 
goal: MonoidHom.mrange f = Submonoid.map f ⊤

full_name: AddMonoidHom.mrange_eq_map
code: @[to_additive]
theorem mrange_eq_map (f : F) : mrange f = (⊤ : Submonoid M).map f 
goal: AddMonoidHom.mrange f = AddSubmonoid.map f ⊤

full_name: AddMonoidHom.mrange_id
code: @[to_additive (attr := simp)]
theorem mrange_id : mrange (MonoidHom.id M) = ⊤ 
goal: AddMonoidHom.mrange (AddMonoidHom.id M) = ⊤

full_name: MonoidHom.mrange_id
code: @[to_additive (attr := simp)]
theorem mrange_id : mrange (MonoidHom.id M) = ⊤ 
goal: MonoidHom.mrange (MonoidHom.id M) = ⊤

full_name: AddMonoidHom.map_mrange
code: @[to_additive]
theorem map_mrange (g : N →* P) (f : M →* N) : f.mrange.map g = mrange (comp g f) 
goal: AddSubmonoid.map g (AddMonoidHom.mrange f) = AddMonoidHom.mrange (g.comp f)

full_name: MonoidHom.map_mrange
code: @[to_additive]
theorem map_mrange (g : N →* P) (f : M →* N) : f.mrange.map g = mrange (comp g f) 
goal: Submonoid.map g (MonoidHom.mrange f) = MonoidHom.mrange (g.comp f)

full_name: MonoidHom.mrange_top_iff_surjective
code: @[to_additive]
theorem mrange_top_iff_surjective {f : F} : mrange f = (⊤ : Submonoid N) ↔ Function.Surjective f 
goal: MonoidHom.mrange f = ⊤ ↔ Function.Surjective ⇑f

full_name: AddMonoidHom.mrange_top_iff_surjective
code: @[to_additive]
theorem mrange_top_iff_surjective {f : F} : mrange f = (⊤ : Submonoid N) ↔ Function.Surjective f 
goal: AddMonoidHom.mrange f = ⊤ ↔ Function.Surjective ⇑f

full_name: AddMonoidHom.mrange_top_of_surjective
code: /-- The range of a surjective monoid hom is the whole of the codomain. -/
@[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) 
goal: AddMonoidHom.mrange f = ⊤

full_name: MonoidHom.mrange_top_of_surjective
code: /-- The range of a surjective monoid hom is the whole of the codomain. -/
@[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) 
goal: MonoidHom.mrange f = ⊤

full_name: MonoidHom.mclosure_preimage_le
code: @[to_additive]
theorem mclosure_preimage_le (f : F) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f 
goal: Submonoid.closure (⇑f ⁻¹' s) ≤ Submonoid.comap f (Submonoid.closure s)

full_name: AddMonoidHom.mclosure_preimage_le
code: @[to_additive]
theorem mclosure_preimage_le (f : F) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f 
goal: AddSubmonoid.closure (⇑f ⁻¹' s) ≤ AddSubmonoid.comap f (AddSubmonoid.closure s)

full_name: AddMonoidHom.map_mclosure
code: /-- The image under a monoid hom of the submonoid generated by a set equals the submonoid generated
    by the image of the set. -/
@[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) 
goal: AddSubmonoid.map f (AddSubmonoid.closure s) = AddSubmonoid.closure (⇑f '' s)

full_name: MonoidHom.map_mclosure
code: /-- The image under a monoid hom of the submonoid generated by a set equals the submonoid generated
    by the image of the set. -/
@[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) 
goal: Submonoid.map f (Submonoid.closure s) = Submonoid.closure (⇑f '' s)

full_name: AddMonoidHom.mclosure_range
code: @[to_additive (attr := simp)]
theorem mclosure_range (f : F) : closure (Set.range f) = mrange f 
goal: AddSubmonoid.closure (Set.range ⇑f) = AddMonoidHom.mrange f

full_name: MonoidHom.mclosure_range
code: @[to_additive (attr := simp)]
theorem mclosure_range (f : F) : closure (Set.range f) = mrange f 
goal: Submonoid.closure (Set.range ⇑f) = MonoidHom.mrange f

full_name: MonoidHom.restrict
code: /-- Restriction of a monoid hom to a submonoid of the domain. -/
@[to_additive "Restriction of an `AddMonoid` hom to an `AddSubmonoid` of the domain."]
def restrict {N S : Type*} [MulOneClass N] [SetLike S M] [SubmonoidClass S M] (f : M →* N)
    (s : S) : s →* N 
goal: ↥s →* N

full_name: AddMonoidHom.restrict
code: /-- Restriction of a monoid hom to a submonoid of the domain. -/
@[to_additive "Restriction of an `AddMonoid` hom to an `AddSubmonoid` of the domain."]
def restrict {N S : Type*} [MulOneClass N] [SetLike S M] [SubmonoidClass S M] (f : M →* N)
    (s : S) : s →* N 
goal: ↥s →+ N

full_name: MonoidHom.restrict_apply
code: @[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 
goal: (f.restrict s) x = f ↑x

full_name: AddMonoidHom.restrict_apply
code: @[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 
goal: (f.restrict s) x = f ↑x

full_name: MonoidHom.restrict_mrange
code: @[to_additive (attr := simp)]
theorem restrict_mrange (f : M →* N) : mrange (f.restrict S) = S.map f 
goal: MonoidHom.mrange (f.restrict S) = Submonoid.map f S

full_name: AddMonoidHom.restrict_mrange
code: @[to_additive (attr := simp)]
theorem restrict_mrange (f : M →* N) : mrange (f.restrict S) = S.map f 
goal: AddMonoidHom.mrange (f.restrict S) = AddSubmonoid.map f S

full_name: MonoidHom.codRestrict_apply
code: /-- Restriction of a monoid hom to a submonoid of the codomain. -/
@[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 
goal: (f.codRestrict s h) n = ⟨f n, ⋯⟩

full_name: AddMonoidHom.codRestrict
code: /-- Restriction of a monoid hom to a submonoid of the codomain. -/
@[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 
goal: M →+ ↥s

full_name: MonoidHom.codRestrict
code: /-- Restriction of a monoid hom to a submonoid of the codomain. -/
@[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 
goal: M →* ↥s

full_name: AddMonoidHom.codRestrict_apply
code: /-- Restriction of a monoid hom to a submonoid of the codomain. -/
@[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 
goal: (f.codRestrict s h) n = ⟨f n, ⋯⟩

full_name: MonoidHom.mrangeRestrict
code: /-- Restriction of a monoid hom to its range interpreted as a submonoid. -/
@[to_additive "Restriction of an `AddMonoid` hom to its range interpreted as a submonoid."]
def mrangeRestrict {N} [MulOneClass N] (f : M →* N) : M →* (mrange f) 
goal: M →* ↥(MonoidHom.mrange f)

full_name: AddMonoidHom.mrangeRestrict
code: /-- Restriction of a monoid hom to its range interpreted as a submonoid. -/
@[to_additive "Restriction of an `AddMonoid` hom to its range interpreted as a submonoid."]
def mrangeRestrict {N} [MulOneClass N] (f : M →* N) : M →* (mrange f) 
goal: M →+ ↥(AddMonoidHom.mrange f)

full_name: AddMonoidHom.coe_mrangeRestrict
code: @[to_additive (attr := simp)]
theorem coe_mrangeRestrict {N} [MulOneClass N] (f : M →* N) (x : M) :
    (f.mrangeRestrict x : N) = f x 
goal: ↑(f.mrangeRestrict x) = f x

full_name: MonoidHom.coe_mrangeRestrict
code: @[to_additive (attr := simp)]
theorem coe_mrangeRestrict {N} [MulOneClass N] (f : M →* N) (x : M) :
    (f.mrangeRestrict x : N) = f x 
goal: ↑(f.mrangeRestrict x) = f x

full_name: AddMonoidHom.mrangeRestrict_surjective
code: @[to_additive]
theorem mrangeRestrict_surjective (f : M →* N) : Function.Surjective f.mrangeRestrict 
goal: Function.Surjective ⇑f.mrangeRestrict

full_name: MonoidHom.mrangeRestrict_surjective
code: @[to_additive]
theorem mrangeRestrict_surjective (f : M →* N) : Function.Surjective f.mrangeRestrict 
goal: Function.Surjective ⇑f.mrangeRestrict

full_name: MonoidHom.mker
code: /-- The multiplicative kernel of a monoid hom is the submonoid of elements `x : G` such
that `f x = 1` -/
@[to_additive
      "The additive kernel of an `AddMonoid` hom is the `AddSubmonoid` of
      elements such that `f x = 0`"]
def mker (f : F) : Submonoid M 
goal: Submonoid M

full_name: AddMonoidHom.mker
code: /-- The multiplicative kernel of a monoid hom is the submonoid of elements `x : G` such
that `f x = 1` -/
@[to_additive
      "The additive kernel of an `AddMonoid` hom is the `AddSubmonoid` of
      elements such that `f x = 0`"]
def mker (f : F) : Submonoid M 
goal: AddSubmonoid M

full_name: MonoidHom.mem_mker
code: @[to_additive]
theorem mem_mker (f : F) {x : M} : x ∈ mker f ↔ f x = 1 
goal: x ∈ MonoidHom.mker f ↔ f x = 1

full_name: AddMonoidHom.mem_mker
code: @[to_additive]
theorem mem_mker (f : F) {x : M} : x ∈ mker f ↔ f x = 1 
goal: x ∈ AddMonoidHom.mker f ↔ f x = 0

full_name: MonoidHom.coe_mker
code: @[to_additive]
theorem coe_mker (f : F) : (mker f : Set M) = (f : M → N) ⁻¹' {1} 
goal: ↑(MonoidHom.mker f) = ⇑f ⁻¹' {1}

full_name: AddMonoidHom.coe_mker
code: @[to_additive]
theorem coe_mker (f : F) : (mker f : Set M) = (f : M → N) ⁻¹' {1} 
goal: ↑(AddMonoidHom.mker f) = ⇑f ⁻¹' {0}

full_name: AddMonoidHom.decidableMemMker
code: @[to_additive]
instance decidableMemMker [DecidableEq N] (f : F) : DecidablePred (· ∈ mker f) 
goal: DecidablePred fun x => x ∈ AddMonoidHom.mker f

full_name: MonoidHom.decidableMemMker
code: @[to_additive]
instance decidableMemMker [DecidableEq N] (f : F) : DecidablePred (· ∈ mker f) 
goal: DecidablePred fun x => x ∈ MonoidHom.mker f

full_name: AddMonoidHom.comap_mker
code: @[to_additive]
theorem comap_mker (g : N →* P) (f : M →* N) : g.mker.comap f = mker (comp g f) 
goal: AddSubmonoid.comap f (AddMonoidHom.mker g) = AddMonoidHom.mker (g.comp f)

full_name: MonoidHom.comap_mker
code: @[to_additive]
theorem comap_mker (g : N →* P) (f : M →* N) : g.mker.comap f = mker (comp g f) 
goal: Submonoid.comap f (MonoidHom.mker g) = MonoidHom.mker (g.comp f)

full_name: AddMonoidHom.comap_bot'
code: @[to_additive (attr := simp)]
theorem comap_bot' (f : F) : (⊥ : Submonoid N).comap f = mker f 
goal: AddSubmonoid.comap f ⊥ = AddMonoidHom.mker f

full_name: MonoidHom.comap_bot'
code: @[to_additive (attr := simp)]
theorem comap_bot' (f : F) : (⊥ : Submonoid N).comap f = mker f 
goal: Submonoid.comap f ⊥ = MonoidHom.mker f

full_name: AddMonoidHom.restrict_mker
code: @[to_additive (attr := simp)]
theorem restrict_mker (f : M →* N) : mker (f.restrict S) = f.mker.comap S.subtype 
goal: AddMonoidHom.mker (f.restrict S) = AddSubmonoid.comap S.subtype (AddMonoidHom.mker f)

full_name: MonoidHom.restrict_mker
code: @[to_additive (attr := simp)]
theorem restrict_mker (f : M →* N) : mker (f.restrict S) = f.mker.comap S.subtype 
goal: MonoidHom.mker (f.restrict S) = Submonoid.comap S.subtype (MonoidHom.mker f)

full_name: MonoidHom.mrangeRestrict_mker
code: @[to_additive]
theorem mrangeRestrict_mker (f : M →* N) : mker (mrangeRestrict f) = mker f 
goal: MonoidHom.mker f.mrangeRestrict = MonoidHom.mker f

full_name: AddMonoidHom.mrangeRestrict_mker
code: @[to_additive]
theorem mrangeRestrict_mker (f : M →* N) : mker (mrangeRestrict f) = mker f 
goal: AddMonoidHom.mker f.mrangeRestrict = AddMonoidHom.mker f

full_name: AddMonoidHom.mker_zero
code: @[to_additive (attr := simp)]
theorem mker_one : mker (1 : M →* N) = ⊤ 
goal: AddMonoidHom.mker 0 = ⊤

full_name: MonoidHom.mker_one
code: @[to_additive (attr := simp)]
theorem mker_one : mker (1 : M →* N) = ⊤ 
goal: MonoidHom.mker 1 = ⊤

full_name: AddMonoidHom.prod_map_comap_prod'
code: @[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) 
goal: AddSubmonoid.comap (f.prodMap g) (S.prod S') = (AddSubmonoid.comap f S).prod (AddSubmonoid.comap g S')

full_name: MonoidHom.prod_map_comap_prod'
code: @[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) 
goal: Submonoid.comap (f.prodMap g) (S.prod S') = (Submonoid.comap f S).prod (Submonoid.comap g S')

full_name: MonoidHom.mker_prod_map
code: @[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) 
goal: MonoidHom.mker (f.prodMap g) = (MonoidHom.mker f).prod (MonoidHom.mker g)

full_name: AddMonoidHom.mker_prod_map
code: @[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) 
goal: AddMonoidHom.mker (f.prodMap g) = (AddMonoidHom.mker f).prod (AddMonoidHom.mker g)

full_name: AddMonoidHom.mker_inl
code: @[to_additive (attr := simp)]
theorem mker_inl : mker (inl M N) = ⊥ 
goal: AddMonoidHom.mker (AddMonoidHom.inl M N) = ⊥

full_name: MonoidHom.mker_inl
code: @[to_additive (attr := simp)]
theorem mker_inl : mker (inl M N) = ⊥ 
goal: MonoidHom.mker (MonoidHom.inl M N) = ⊥

full_name: AddMonoidHom.mker_inr
code: @[to_additive (attr := simp)]
theorem mker_inr : mker (inr M N) = ⊥ 
goal: AddMonoidHom.mker (AddMonoidHom.inr M N) = ⊥

full_name: MonoidHom.mker_inr
code: @[to_additive (attr := simp)]
theorem mker_inr : mker (inr M N) = ⊥ 
goal: MonoidHom.mker (MonoidHom.inr M N) = ⊥

full_name: MonoidHom.mker_fst
code: @[to_additive (attr := simp)]
lemma mker_fst : mker (fst M N) = .prod ⊥ ⊤ 
goal: MonoidHom.mker (MonoidHom.fst M N) = ⊥.prod ⊤

full_name: AddMonoidHom.mker_fst
code: @[to_additive (attr := simp)]
lemma mker_fst : mker (fst M N) = .prod ⊥ ⊤ 
goal: AddMonoidHom.mker (AddMonoidHom.fst M N) = ⊥.prod ⊤

full_name: AddMonoidHom.mker_snd
code: @[to_additive (attr := simp)]
lemma mker_snd : mker (snd M N) = .prod ⊤ ⊥ 
goal: AddMonoidHom.mker (AddMonoidHom.snd M N) = ⊤.prod ⊥

full_name: MonoidHom.mker_snd
code: @[to_additive (attr := simp)]
lemma mker_snd : mker (snd M N) = .prod ⊤ ⊥ 
goal: MonoidHom.mker (MonoidHom.snd M N) = ⊤.prod ⊥

full_name: AddMonoidHom.addSubmonoidComap
code: /-- The `MonoidHom` from the preimage of a submonoid to itself. -/
@[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' 
goal: ↥(AddSubmonoid.comap f N') →+ ↥N'

full_name: MonoidHom.submonoidComap
code: /-- The `MonoidHom` from the preimage of a submonoid to itself. -/
@[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' 
goal: ↥(Submonoid.comap f N') →* ↥N'

full_name: AddMonoidHom.addSubmonoidComap_apply_coe
code: /-- The `MonoidHom` from the preimage of a submonoid to itself. -/
@[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' 
goal: ↑((f.addSubmonoidComap N') x) = f ↑x

full_name: MonoidHom.submonoidComap_apply_coe
code: /-- The `MonoidHom` from the preimage of a submonoid to itself. -/
@[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' 
goal: ↑((f.submonoidComap N') x) = f ↑x

full_name: MonoidHom.submonoidMap_apply_coe
code: /-- The `MonoidHom` from a submonoid to its image.
See `MulEquiv.SubmonoidMap` for a variant for `MulEquiv`s. -/
@[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 
goal: ↑((f.submonoidMap M') x) = f ↑x

full_name: AddMonoidHom.addSubmonoidMap
code: /-- The `MonoidHom` from a submonoid to its image.
See `MulEquiv.SubmonoidMap` for a variant for `MulEquiv`s. -/
@[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 
goal: ↥M' →+ ↥(AddSubmonoid.map f M')

full_name: MonoidHom.submonoidMap
code: /-- The `MonoidHom` from a submonoid to its image.
See `MulEquiv.SubmonoidMap` for a variant for `MulEquiv`s. -/
@[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 
goal: ↥M' →* ↥(Submonoid.map f M')

full_name: AddMonoidHom.addSubmonoidMap_apply_coe
code: /-- The `MonoidHom` from a submonoid to its image.
See `MulEquiv.SubmonoidMap` for a variant for `MulEquiv`s. -/
@[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 
goal: ↑((f.addSubmonoidMap M') x) = f ↑x

full_name: MonoidHom.submonoidMap_surjective
code: @[to_additive]
theorem submonoidMap_surjective (f : M →* N) (M' : Submonoid M) :
    Function.Surjective (f.submonoidMap M') 
goal: Function.Surjective ⇑(f.submonoidMap M')

full_name: AddMonoidHom.addSubmonoidMap_surjective
code: @[to_additive]
theorem submonoidMap_surjective (f : M →* N) (M' : Submonoid M) :
    Function.Surjective (f.submonoidMap M') 
goal: Function.Surjective ⇑(f.addSubmonoidMap M')

full_name: Submonoid.mrange_inl
code: @[to_additive]
theorem mrange_inl : mrange (inl M N) = prod ⊤ ⊥ 
goal: MonoidHom.mrange (MonoidHom.inl M N) = ⊤.prod ⊥

full_name: AddSubmonoid.mrange_inl
code: @[to_additive]
theorem mrange_inl : mrange (inl M N) = prod ⊤ ⊥ 
goal: AddMonoidHom.mrange (AddMonoidHom.inl M N) = ⊤.prod ⊥

full_name: Submonoid.mrange_inr
code: @[to_additive]
theorem mrange_inr : mrange (inr M N) = prod ⊥ ⊤ 
goal: MonoidHom.mrange (MonoidHom.inr M N) = ⊥.prod ⊤

full_name: AddSubmonoid.mrange_inr
code: @[to_additive]
theorem mrange_inr : mrange (inr M N) = prod ⊥ ⊤ 
goal: AddMonoidHom.mrange (AddMonoidHom.inr M N) = ⊥.prod ⊤

full_name: Submonoid.mrange_inl'
code: @[to_additive]
theorem mrange_inl' : mrange (inl M N) = comap (snd M N) ⊥ 
goal: MonoidHom.mrange (MonoidHom.inl M N) = Submonoid.comap (MonoidHom.snd M N) ⊥

full_name: AddSubmonoid.mrange_inl'
code: @[to_additive]
theorem mrange_inl' : mrange (inl M N) = comap (snd M N) ⊥ 
goal: AddMonoidHom.mrange (AddMonoidHom.inl M N) = AddSubmonoid.comap (AddMonoidHom.snd M N) ⊥

full_name: Submonoid.mrange_inr'
code: @[to_additive]
theorem mrange_inr' : mrange (inr M N) = comap (fst M N) ⊥ 
goal: MonoidHom.mrange (MonoidHom.inr M N) = Submonoid.comap (MonoidHom.fst M N) ⊥

full_name: AddSubmonoid.mrange_inr'
code: @[to_additive]
theorem mrange_inr' : mrange (inr M N) = comap (fst M N) ⊥ 
goal: AddMonoidHom.mrange (AddMonoidHom.inr M N) = AddSubmonoid.comap (AddMonoidHom.fst M N) ⊥

full_name: AddSubmonoid.mrange_fst
code: @[to_additive (attr := simp)]
theorem mrange_fst : mrange (fst M N) = ⊤ 
goal: AddMonoidHom.mrange (AddMonoidHom.fst M N) = ⊤

full_name: Submonoid.mrange_fst
code: @[to_additive (attr := simp)]
theorem mrange_fst : mrange (fst M N) = ⊤ 
goal: MonoidHom.mrange (MonoidHom.fst M N) = ⊤

full_name: Submonoid.mrange_snd
code: @[to_additive (attr := simp)]
theorem mrange_snd : mrange (snd M N) = ⊤ 
goal: MonoidHom.mrange (MonoidHom.snd M N) = ⊤

full_name: AddSubmonoid.mrange_snd
code: @[to_additive (attr := simp)]
theorem mrange_snd : mrange (snd M N) = ⊤ 
goal: AddMonoidHom.mrange (AddMonoidHom.snd M N) = ⊤

full_name: AddSubmonoid.prod_eq_bot_iff
code: @[to_additive prod_eq_bot_iff]
theorem prod_eq_bot_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥ 
goal: s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥

full_name: Submonoid.prod_eq_bot_iff
code: @[to_additive prod_eq_bot_iff]
theorem prod_eq_bot_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥ 
goal: s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥

full_name: Submonoid.prod_eq_top_iff
code: @[to_additive prod_eq_top_iff]
theorem prod_eq_top_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ 
goal: s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤

full_name: AddSubmonoid.prod_eq_top_iff
code: @[to_additive prod_eq_top_iff]
theorem prod_eq_top_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ 
goal: s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤

full_name: AddSubmonoid.mrange_inl_sup_mrange_inr
code: @[to_additive (attr := simp)]
theorem mrange_inl_sup_mrange_inr : mrange (inl M N) ⊔ mrange (inr M N) = ⊤ 
goal: AddMonoidHom.mrange (AddMonoidHom.inl M N) ⊔ AddMonoidHom.mrange (AddMonoidHom.inr M N) = ⊤

full_name: Submonoid.mrange_inl_sup_mrange_inr
code: @[to_additive (attr := simp)]
theorem mrange_inl_sup_mrange_inr : mrange (inl M N) ⊔ mrange (inr M N) = ⊤ 
goal: MonoidHom.mrange (MonoidHom.inl M N) ⊔ MonoidHom.mrange (MonoidHom.inr M N) = ⊤

full_name: AddSubmonoid.inclusion
code: /-- The monoid hom associated to an inclusion of submonoids. -/
@[to_additive
      "The `AddMonoid` hom associated to an inclusion of submonoids."]
def inclusion {S T : Submonoid M} (h : S ≤ T) : S →* T 
goal: ↥S →+ ↥T

full_name: Submonoid.inclusion
code: /-- The monoid hom associated to an inclusion of submonoids. -/
@[to_additive
      "The `AddMonoid` hom associated to an inclusion of submonoids."]
def inclusion {S T : Submonoid M} (h : S ≤ T) : S →* T 
goal: ↥S →* ↥T

full_name: Submonoid.range_subtype
code: @[to_additive (attr := simp)]
theorem range_subtype (s : Submonoid M) : mrange s.subtype = s 
goal: MonoidHom.mrange s.subtype = s

full_name: AddSubmonoid.range_subtype
code: @[to_additive (attr := simp)]
theorem range_subtype (s : Submonoid M) : mrange s.subtype = s 
goal: AddMonoidHom.mrange s.subtype = s

full_name: Submonoid.eq_top_iff'
code: @[to_additive]
theorem eq_top_iff' : S = ⊤ ↔ ∀ x : M, x ∈ S 
goal: S = ⊤ ↔ ∀ (x : M), x ∈ S

full_name: AddSubmonoid.eq_top_iff'
code: @[to_additive]
theorem eq_top_iff' : S = ⊤ ↔ ∀ x : M, x ∈ S 
goal: S = ⊤ ↔ ∀ (x : M), x ∈ S

full_name: Submonoid.eq_bot_iff_forall
code: @[to_additive]
theorem eq_bot_iff_forall : S = ⊥ ↔ ∀ x ∈ S, x = (1 : M) 
goal: S = ⊥ ↔ ∀ x ∈ S, x = 1

full_name: AddSubmonoid.eq_bot_iff_forall
code: @[to_additive]
theorem eq_bot_iff_forall : S = ⊥ ↔ ∀ x ∈ S, x = (1 : M) 
goal: S = ⊥ ↔ ∀ x ∈ S, x = 0

full_name: Submonoid.eq_bot_of_subsingleton
code: @[to_additive]
theorem eq_bot_of_subsingleton [Subsingleton S] : S = ⊥ 
goal: S = ⊥

full_name: AddSubmonoid.eq_bot_of_subsingleton
code: @[to_additive]
theorem eq_bot_of_subsingleton [Subsingleton S] : S = ⊥ 
goal: S = ⊥

full_name: Submonoid.nontrivial_iff_exists_ne_one
code: @[to_additive]
theorem nontrivial_iff_exists_ne_one (S : Submonoid M) : Nontrivial S ↔ ∃ x ∈ S, x ≠ (1 : M) 
goal: Nontrivial ↥S ↔ ∃ x ∈ S, x ≠ 1

full_name: AddSubmonoid.nontrivial_iff_exists_ne_zero
code: @[to_additive]
theorem nontrivial_iff_exists_ne_one (S : Submonoid M) : Nontrivial S ↔ ∃ x ∈ S, x ≠ (1 : M) 
goal: Nontrivial ↥S ↔ ∃ x ∈ S, x ≠ 0

full_name: AddSubmonoid.bot_or_nontrivial
code: /-- A submonoid is either the trivial submonoid or nontrivial. -/
@[to_additive "An additive submonoid is either the trivial additive submonoid or nontrivial."]
theorem bot_or_nontrivial (S : Submonoid M) : S = ⊥ ∨ Nontrivial S 
goal: S = ⊥ ∨ Nontrivial ↥S

full_name: Submonoid.bot_or_nontrivial
code: /-- A submonoid is either the trivial submonoid or nontrivial. -/
@[to_additive "An additive submonoid is either the trivial additive submonoid or nontrivial."]
theorem bot_or_nontrivial (S : Submonoid M) : S = ⊥ ∨ Nontrivial S 
goal: S = ⊥ ∨ Nontrivial ↥S

full_name: Submonoid.bot_or_exists_ne_one
code: /-- A submonoid is either the trivial submonoid or contains a nonzero element. -/
@[to_additive
      "An additive submonoid is either the trivial additive submonoid or contains a nonzero
      element."]
theorem bot_or_exists_ne_one (S : Submonoid M) : S = ⊥ ∨ ∃ x ∈ S, x ≠ (1 : M) 
goal: S = ⊥ ∨ ∃ x ∈ S, x ≠ 1

full_name: AddSubmonoid.bot_or_exists_ne_zero
code: /-- A submonoid is either the trivial submonoid or contains a nonzero element. -/
@[to_additive
      "An additive submonoid is either the trivial additive submonoid or contains a nonzero
      element."]
theorem bot_or_exists_ne_one (S : Submonoid M) : S = ⊥ ∨ ∃ x ∈ S, x ≠ (1 : M) 
goal: S = ⊥ ∨ ∃ x ∈ S, x ≠ 0

full_name: AddEquiv.addSubmonoidCongr
code: /-- Makes the identity isomorphism from a proof that two submonoids of a multiplicative
    monoid are equal. -/
@[to_additive
      "Makes the identity additive isomorphism from a proof two
      submonoids of an additive monoid are equal."]
def submonoidCongr (h : S = T) : S ≃* T 
goal: ↥S ≃+ ↥T

full_name: MulEquiv.submonoidCongr
code: /-- Makes the identity isomorphism from a proof that two submonoids of a multiplicative
    monoid are equal. -/
@[to_additive
      "Makes the identity additive isomorphism from a proof two
      submonoids of an additive monoid are equal."]
def submonoidCongr (h : S = T) : S ≃* T 
goal: ↥S ≃* ↥T

full_name: MulEquiv.ofLeftInverse'
code: /-- A monoid homomorphism `f : M →* N` with a left-inverse `g : N → M` defines a multiplicative
equivalence between `M` and `f.mrange`.
This is a bidirectional version of `MonoidHom.mrange_restrict`. -/
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
goal: M ≃* ↥(MonoidHom.mrange f)

full_name: AddEquiv.ofLeftInverse'_symm_apply
code: /-- A monoid homomorphism `f : M →* N` with a left-inverse `g : N → M` defines a multiplicative
equivalence between `M` and `f.mrange`.
This is a bidirectional version of `MonoidHom.mrange_restrict`. -/
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
goal: ∀ (a : ↥(AddMonoidHom.mrange f)), (AddEquiv.ofLeftInverse' f h).symm a = g ↑a

full_name: MulEquiv.ofLeftInverse'_symm_apply
code: /-- A monoid homomorphism `f : M →* N` with a left-inverse `g : N → M` defines a multiplicative
equivalence between `M` and `f.mrange`.
This is a bidirectional version of `MonoidHom.mrange_restrict`. -/
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
goal: ∀ (a : ↥(MonoidHom.mrange f)), (MulEquiv.ofLeftInverse' f h).symm a = g ↑a

full_name: AddEquiv.ofLeftInverse'_apply
code: /-- A monoid homomorphism `f : M →* N` with a left-inverse `g : N → M` defines a multiplicative
equivalence between `M` and `f.mrange`.
This is a bidirectional version of `MonoidHom.mrange_restrict`. -/
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
goal: (AddEquiv.ofLeftInverse' f h) a = f.mrangeRestrict a

full_name: MulEquiv.ofLeftInverse'_apply
code: /-- A monoid homomorphism `f : M →* N` with a left-inverse `g : N → M` defines a multiplicative
equivalence between `M` and `f.mrange`.
This is a bidirectional version of `MonoidHom.mrange_restrict`. -/
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
goal: (MulEquiv.ofLeftInverse' f h) a = f.mrangeRestrict a

full_name: AddEquiv.ofLeftInverse'
code: /-- A monoid homomorphism `f : M →* N` with a left-inverse `g : N → M` defines a multiplicative
equivalence between `M` and `f.mrange`.
This is a bidirectional version of `MonoidHom.mrange_restrict`. -/
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
goal: M ≃+ ↥(AddMonoidHom.mrange f)

full_name: AddEquiv.addSubmonoidMap
code: /-- A `MulEquiv` `φ` between two monoids `M` and `N` induces a `MulEquiv` between
a submonoid `S ≤ M` and the submonoid `φ(S) ≤ N`.
See `MonoidHom.submonoidMap` for a variant for `MonoidHom`s. -/
@[to_additive
      "An `AddEquiv` `φ` between two additive monoids `M` and `N` induces an `AddEquiv`
      between a submonoid `S ≤ M` and the submonoid `φ(S) ≤ N`. See
      `AddMonoidHom.addSubmonoidMap` for a variant for `AddMonoidHom`s."]
def submonoidMap (e : M ≃* N) (S : Submonoid M) : S ≃* S.map e 
goal: ↥S ≃+ ↥(AddSubmonoid.map e S)

full_name: MulEquiv.submonoidMap
code: /-- A `MulEquiv` `φ` between two monoids `M` and `N` induces a `MulEquiv` between
a submonoid `S ≤ M` and the submonoid `φ(S) ≤ N`.
See `MonoidHom.submonoidMap` for a variant for `MonoidHom`s. -/
@[to_additive
      "An `AddEquiv` `φ` between two additive monoids `M` and `N` induces an `AddEquiv`
      between a submonoid `S ≤ M` and the submonoid `φ(S) ≤ N`. See
      `AddMonoidHom.addSubmonoidMap` for a variant for `AddMonoidHom`s."]
def submonoidMap (e : M ≃* N) (S : Submonoid M) : S ≃* S.map e 
goal: ↥S ≃* ↥(Submonoid.map e S)

full_name: MulEquiv.coe_submonoidMap_apply
code: @[to_additive (attr := simp)]
theorem coe_submonoidMap_apply (e : M ≃* N) (S : Submonoid M) (g : S) :
    ((submonoidMap e S g : S.map (e : M →* N)) : N) = e g 
goal: ↑((e.submonoidMap S) g) = e ↑g

full_name: AddEquiv.coe_addSubmonoidMap_apply
code: @[to_additive (attr := simp)]
theorem coe_submonoidMap_apply (e : M ≃* N) (S : Submonoid M) (g : S) :
    ((submonoidMap e S g : S.map (e : M →* N)) : N) = e g 
goal: ↑((e.addSubmonoidMap S) g) = e ↑g

full_name: AddEquiv.add_submonoid_map_symm_apply
code: @[to_additive (attr := simp) AddEquiv.add_submonoid_map_symm_apply]
theorem submonoidMap_symm_apply (e : M ≃* N) (S : Submonoid M) (g : S.map (e : M →* N)) :
    (e.submonoidMap S).symm g = ⟨e.symm g, SetLike.mem_coe.1 <| Set.mem_image_equiv.1 g.2⟩ 
goal: (e.addSubmonoidMap S).symm g = ⟨e.symm ↑g, ⋯⟩

full_name: MulEquiv.submonoidMap_symm_apply
code: @[to_additive (attr := simp) AddEquiv.add_submonoid_map_symm_apply]
theorem submonoidMap_symm_apply (e : M ≃* N) (S : Submonoid M) (g : S.map (e : M →* N)) :
    (e.submonoidMap S).symm g = ⟨e.symm g, SetLike.mem_coe.1 <| Set.mem_image_equiv.1 g.2⟩ 
goal: (e.submonoidMap S).symm g = ⟨e.symm ↑g, ⋯⟩

full_name: AddSubmonoid.equivMapOfInjective_coe_addEquiv
code: @[to_additive (attr := simp)]
theorem Submonoid.equivMapOfInjective_coe_mulEquiv (e : M ≃* N) :
    S.equivMapOfInjective (e : M →* N) (EquivLike.injective e) = e.submonoidMap S 
goal: S.equivMapOfInjective ↑e ⋯ = e.addSubmonoidMap S

full_name: Submonoid.equivMapOfInjective_coe_mulEquiv
code: @[to_additive (attr := simp)]
theorem Submonoid.equivMapOfInjective_coe_mulEquiv (e : M ≃* N) :
    S.equivMapOfInjective (e : M →* N) (EquivLike.injective e) = e.submonoidMap S 
goal: S.equivMapOfInjective ↑e ⋯ = e.submonoidMap S

full_name: AddSubmonoid.vadd
code: @[to_additive]
instance smul [SMul M' α] (S : Submonoid M') : SMul S α 
goal: VAdd (↥S) α

full_name: Submonoid.smul
code: @[to_additive]
instance smul [SMul M' α] (S : Submonoid M') : SMul S α 
goal: SMul (↥S) α

full_name: AddSubmonoid.vaddCommClass_left
code: @[to_additive]
instance smulCommClass_left [SMul M' β] [SMul α β] [SMulCommClass M' α β]
    (S : Submonoid M') : SMulCommClass S α β 
goal: VAddCommClass (↥S) α β

full_name: Submonoid.smulCommClass_left
code: @[to_additive]
instance smulCommClass_left [SMul M' β] [SMul α β] [SMulCommClass M' α β]
    (S : Submonoid M') : SMulCommClass S α β 
goal: SMulCommClass (↥S) α β

full_name: Submonoid.smulCommClass_right
code: @[to_additive]
instance smulCommClass_right [SMul α β] [SMul M' β] [SMulCommClass α M' β]
    (S : Submonoid M') : SMulCommClass α S β 
goal: SMulCommClass α (↥S) β

full_name: AddSubmonoid.vaddCommClass_right
code: @[to_additive]
instance smulCommClass_right [SMul α β] [SMul M' β] [SMulCommClass α M' β]
    (S : Submonoid M') : SMulCommClass α S β 
goal: VAddCommClass α (↥S) β

full_name: Submonoid.isScalarTower
code: /-- Note that this provides `IsScalarTower S M' M'` which is needed by `SMulMulAssoc`. -/
instance isScalarTower [SMul α β] [SMul M' α] [SMul M' β] [IsScalarTower M' α β]
      (S : Submonoid M') :
    IsScalarTower S α β 
goal: IsScalarTower (↥S) α β

full_name: Submonoid.smul_def
code: @[to_additive] lemma smul_def (g : S) (a : α) : g • a = (g : M') • a 
goal: g • a = ↑g • a

full_name: AddSubmonoid.vadd_def
code: @[to_additive] lemma smul_def (g : S) (a : α) : g • a = (g : M') • a 
goal: g +ᵥ a = ↑g +ᵥ a

full_name: AddSubmonoid.mk_vadd
code: @[to_additive (attr := simp)]
lemma mk_smul (g : M') (hg : g ∈ S) (a : α) : (⟨g, hg⟩ : S) • a = g • a 
goal: ⟨g, hg⟩ +ᵥ a = g +ᵥ a

full_name: Submonoid.mk_smul
code: @[to_additive (attr := simp)]
lemma mk_smul (g : M') (hg : g ∈ S) (a : α) : (⟨g, hg⟩ : S) • a = g • a 
goal: ⟨g, hg⟩ • a = g • a

full_name: Submonoid.faithfulSMul
code: instance faithfulSMul [FaithfulSMul M' α] : FaithfulSMul S α 
goal: FaithfulSMul (↥S) α

full_name: Submonoid.mulAction
code: /-- The action by a submonoid is the action by the underlying monoid. -/
@[to_additive
      "The additive action by an `AddSubmonoid` is the action by the underlying `AddMonoid`. "]
instance mulAction [MulAction M' α] (S : Submonoid M') : MulAction S α 
goal: MulAction (↥S) α

full_name: AddSubmonoid.addAction
code: /-- The action by a submonoid is the action by the underlying monoid. -/
@[to_additive
      "The additive action by an `AddSubmonoid` is the action by the underlying `AddMonoid`. "]
instance mulAction [MulAction M' α] (S : Submonoid M') : MulAction S α 
goal: AddAction (↥S) α

full_name: Submonoid.val_unitsTypeEquivIsUnitSubmonoid_symm_apply
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: ↑(Submonoid.unitsTypeEquivIsUnitSubmonoid.symm x) = ↑x

full_name: Submonoid.unitsTypeEquivIsUnitSubmonoid_apply_coe
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: ↑(Submonoid.unitsTypeEquivIsUnitSubmonoid x) = ↑x

full_name: AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid_apply_coe
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: ↑(AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid x) = ↑x

full_name: AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: AddUnits M ≃+ ↥(IsAddUnit.addSubmonoid M)

full_name: Submonoid.unitsTypeEquivIsUnitSubmonoid
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: Mˣ ≃* ↥(IsUnit.submonoid M)

full_name: AddSubmonoid.val_addUnitsTypeEquivIsAddUnitAddSubmonoid_symm_apply
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: ↑(AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid.symm x) = ↑x

full_name: Submonoid.val_inv_unitsTypeEquivIsUnitSubmonoid_symm_apply
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: ↑(Submonoid.unitsTypeEquivIsUnitSubmonoid.symm x)⁻¹ = ↑(Classical.choose ⋯)⁻¹

full_name: AddSubmonoid.val_neg_addUnitsTypeEquivIsAddUnitAddSubmonoid_symm_apply
code: /-- The multiplicative equivalence between the type of units of `M` and the submonoid of unit
elements of `M`. -/
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
goal: ↑(-AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid.symm x) = ↑(-Classical.choose ⋯)

full_name: Nat.addSubmonoid_closure_one
code: @[simp] lemma addSubmonoid_closure_one : closure ({1} : Set ℕ) = ⊤ 
goal: AddSubmonoid.closure {1} = ⊤

full_name: Submonoid.map_comap_eq
code: @[to_additive]
theorem map_comap_eq (f : F) (S : Submonoid N) : (S.comap f).map f = S ⊓ MonoidHom.mrange f 
goal: Submonoid.map f (Submonoid.comap f S) = S ⊓ MonoidHom.mrange f

full_name: AddSubmonoid.map_comap_eq
code: @[to_additive]
theorem map_comap_eq (f : F) (S : Submonoid N) : (S.comap f).map f = S ⊓ MonoidHom.mrange f 
goal: AddSubmonoid.map f (AddSubmonoid.comap f S) = S ⊓ AddMonoidHom.mrange f

full_name: Submonoid.map_comap_eq_self
code: @[to_additive]
theorem map_comap_eq_self {f : F} {S : Submonoid N} (h : S ≤ MonoidHom.mrange f) :
    (S.comap f).map f = S 
goal: Submonoid.map f (Submonoid.comap f S) = S

full_name: AddSubmonoid.map_comap_eq_self
code: @[to_additive]
theorem map_comap_eq_self {f : F} {S : Submonoid N} (h : S ≤ MonoidHom.mrange f) :
    (S.comap f).map f = S 
goal: AddSubmonoid.map f (AddSubmonoid.comap f S) = S