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

full_name: OneMemClass
code: /-- `OneMemClass S M` says `S` is a type of subsets `s ≤ M`, such that `1 ∈ s` for all `s`. -/
class OneMemClass (S : Type*) (M : Type*) [One M] [SetLike S M] : Prop where
  /-- By definition, if we have `OneMemClass S M`, we have `1 ∈ s` for all `s : S`. -/
  one_mem : ∀ s : S, (1 : M) ∈ s
goal: Prop

full_name: OneMemClass.one_mem
code: /-- `OneMemClass S M` says `S` is a type of subsets `s ≤ M`, such that `1 ∈ s` for all `s`. -/
class OneMemClass (S : Type*) (M : Type*) [One M] [SetLike S M] : Prop where
  /-- By definition, if we have `OneMemClass S M`, we have `1 ∈ s` for all `s : S`. -/
  one_mem : ∀ s : S, (1 : M) ∈ s
goal: 1 ∈ s

full_name: ZeroMemClass
code: /-- `ZeroMemClass S M` says `S` is a type of subsets `s ≤ M`, such that `0 ∈ s` for all `s`. -/
class ZeroMemClass (S : Type*) (M : Type*) [Zero M] [SetLike S M] : Prop where
  /-- By definition, if we have `ZeroMemClass S M`, we have `0 ∈ s` for all `s : S`. -/
  zero_mem : ∀ s : S, (0 : M) ∈ s
goal: Prop

full_name: ZeroMemClass.zero_mem
code: /-- `ZeroMemClass S M` says `S` is a type of subsets `s ≤ M`, such that `0 ∈ s` for all `s`. -/
class ZeroMemClass (S : Type*) (M : Type*) [Zero M] [SetLike S M] : Prop where
  /-- By definition, if we have `ZeroMemClass S M`, we have `0 ∈ s` for all `s : S`. -/
  zero_mem : ∀ s : S, (0 : M) ∈ s
goal: 0 ∈ s

full_name: Submonoid
code: /-- A submonoid of a monoid `M` is a subset containing 1 and closed under multiplication. -/
structure Submonoid (M : Type*) [MulOneClass M] extends Subsemigroup M where
  /-- A submonoid contains `1`. -/
  one_mem' : (1 : M) ∈ carrier
goal: Type u_4

full_name: Submonoid.one_mem'
code: /-- A submonoid of a monoid `M` is a subset containing 1 and closed under multiplication. -/
structure Submonoid (M : Type*) [MulOneClass M] extends Subsemigroup M where
  /-- A submonoid contains `1`. -/
  one_mem' : (1 : M) ∈ carrier
goal: 1 ∈ self.carrier

full_name: SubmonoidClass
code: /-- `SubmonoidClass S M` says `S` is a type of subsets `s ≤ M` that contain `1`
and are closed under `(*)` -/
class SubmonoidClass (S : Type*) (M : Type*) [MulOneClass M] [SetLike S M] extends
  MulMemClass S M, OneMemClass S M : Prop
goal: Prop

full_name: AddSubmonoid.zero_mem'
code: /-- An additive submonoid of an additive monoid `M` is a subset containing 0 and
  closed under addition. -/
structure AddSubmonoid (M : Type*) [AddZeroClass M] extends AddSubsemigroup M where
  /-- An additive submonoid contains `0`. -/
  zero_mem' : (0 : M) ∈ carrier
goal: 0 ∈ self.carrier

full_name: AddSubmonoid
code: /-- An additive submonoid of an additive monoid `M` is a subset containing 0 and
  closed under addition. -/
structure AddSubmonoid (M : Type*) [AddZeroClass M] extends AddSubsemigroup M where
  /-- An additive submonoid contains `0`. -/
  zero_mem' : (0 : M) ∈ carrier
goal: Type u_4

full_name: AddSubmonoidClass
code: /-- `AddSubmonoidClass S M` says `S` is a type of subsets `s ≤ M` that contain `0`
and are closed under `(+)` -/
class AddSubmonoidClass (S : Type*) (M : Type*) [AddZeroClass M] [SetLike S M] extends
  AddMemClass S M, ZeroMemClass S M : Prop
goal: Prop

full_name: nsmul_mem
code: @[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem pow_mem {M A} [Monoid M] [SetLike A M] [SubmonoidClass A M] {S : A} {x : M}
    (hx : x ∈ S) : ∀ n : ℕ, x ^ n ∈ S
  
goal: n • x ∈ S

full_name: pow_mem
code: @[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem pow_mem {M A} [Monoid M] [SetLike A M] [SubmonoidClass A M] {S : A} {x : M}
    (hx : x ∈ S) : ∀ n : ℕ, x ^ n ∈ S
  
goal: x ^ n ∈ S

full_name: Submonoid.instSetLike
code: @[to_additive]
instance : SetLike (Submonoid M) M 
goal: SetLike (Submonoid M) M

full_name: AddSubmonoid.instSetLike
code: @[to_additive]
instance : SetLike (Submonoid M) M 
goal: SetLike (AddSubmonoid M) M

full_name: AddSubmonoid.instAddSubmonoidClass
code: @[to_additive]
instance : SubmonoidClass (Submonoid M) M 
goal: AddSubmonoidClass (AddSubmonoid M) M

full_name: Submonoid.instSubmonoidClass
code: @[to_additive]
instance : SubmonoidClass (Submonoid M) M 
goal: SubmonoidClass (Submonoid M) M

full_name: Submonoid.mem_toSubsemigroup
code: @[to_additive (attr := simp)]
theorem mem_toSubsemigroup {s : Submonoid M} {x : M} : x ∈ s.toSubsemigroup ↔ x ∈ s 
goal: x ∈ s.toSubsemigroup ↔ x ∈ s

full_name: AddSubmonoid.mem_toSubsemigroup
code: @[to_additive (attr := simp)]
theorem mem_toSubsemigroup {s : Submonoid M} {x : M} : x ∈ s.toSubsemigroup ↔ x ∈ s 
goal: x ∈ s.toAddSubsemigroup ↔ x ∈ s

full_name: Submonoid.mem_carrier
code: @[to_additive]
theorem mem_carrier {s : Submonoid M} {x : M} : x ∈ s.carrier ↔ x ∈ s 
goal: x ∈ s.carrier ↔ x ∈ s

full_name: AddSubmonoid.mem_carrier
code: @[to_additive]
theorem mem_carrier {s : Submonoid M} {x : M} : x ∈ s.carrier ↔ x ∈ s 
goal: x ∈ s.carrier ↔ x ∈ s

full_name: AddSubmonoid.mem_mk
code: @[to_additive (attr := simp)]
theorem mem_mk {s : Subsemigroup M} {x : M} (h_one) : x ∈ mk s h_one ↔ x ∈ s 
goal: x ∈ { toAddSubsemigroup := s, zero_mem' := h_one } ↔ x ∈ s

full_name: Submonoid.mem_mk
code: @[to_additive (attr := simp)]
theorem mem_mk {s : Subsemigroup M} {x : M} (h_one) : x ∈ mk s h_one ↔ x ∈ s 
goal: x ∈ { toSubsemigroup := s, one_mem' := h_one } ↔ x ∈ s

full_name: Submonoid.coe_set_mk
code: @[to_additive (attr := simp)]
theorem coe_set_mk {s : Subsemigroup M} (h_one) : (mk s h_one : Set M) = s 
goal: ↑{ toSubsemigroup := s, one_mem' := h_one } = ↑s

full_name: AddSubmonoid.coe_set_mk
code: @[to_additive (attr := simp)]
theorem coe_set_mk {s : Subsemigroup M} (h_one) : (mk s h_one : Set M) = s 
goal: ↑{ toAddSubsemigroup := s, zero_mem' := h_one } = ↑s

full_name: Submonoid.mk_le_mk
code: @[to_additive (attr := simp)]
theorem mk_le_mk {s t : Subsemigroup M} (h_one) (h_one') : mk s h_one ≤ mk t h_one' ↔ s ≤ t 
goal: { toSubsemigroup := s, one_mem' := h_one } ≤ { toSubsemigroup := t, one_mem' := h_one' } ↔ s ≤ t

full_name: AddSubmonoid.mk_le_mk
code: @[to_additive (attr := simp)]
theorem mk_le_mk {s t : Subsemigroup M} (h_one) (h_one') : mk s h_one ≤ mk t h_one' ↔ s ≤ t 
goal: { toAddSubsemigroup := s, zero_mem' := h_one } ≤ { toAddSubsemigroup := t, zero_mem' := h_one' } ↔ s ≤ t

full_name: Submonoid.ext
code: /-- Two submonoids are equal if they have the same elements. -/
@[to_additive (attr := ext) "Two `AddSubmonoid`s are equal if they have the same elements."]
theorem ext {S T : Submonoid M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
goal: S = T

full_name: AddSubmonoid.ext
code: /-- Two submonoids are equal if they have the same elements. -/
@[to_additive (attr := ext) "Two `AddSubmonoid`s are equal if they have the same elements."]
theorem ext {S T : Submonoid M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
goal: S = T

full_name: Submonoid.copy
code: /-- Copy a submonoid replacing `carrier` with a set that is equal to it. -/
@[to_additive "Copy an additive submonoid replacing `carrier` with a set that is equal to it."]
protected def copy (S : Submonoid M) (s : Set M) (hs : s = S) : Submonoid M 
goal: Submonoid M

full_name: AddSubmonoid.copy
code: /-- Copy a submonoid replacing `carrier` with a set that is equal to it. -/
@[to_additive "Copy an additive submonoid replacing `carrier` with a set that is equal to it."]
protected def copy (S : Submonoid M) (s : Set M) (hs : s = S) : Submonoid M 
goal: AddSubmonoid M

full_name: AddSubmonoid.coe_copy
code: @[to_additive (attr := simp)]
theorem coe_copy {s : Set M} (hs : s = S) : (S.copy s hs : Set M) = s 
goal: ↑(S.copy s hs) = s

full_name: Submonoid.coe_copy
code: @[to_additive (attr := simp)]
theorem coe_copy {s : Set M} (hs : s = S) : (S.copy s hs : Set M) = s 
goal: ↑(S.copy s hs) = s

full_name: Submonoid.copy_eq
code: @[to_additive]
theorem copy_eq {s : Set M} (hs : s = S) : S.copy s hs = S 
goal: S.copy s hs = S

full_name: AddSubmonoid.copy_eq
code: @[to_additive]
theorem copy_eq {s : Set M} (hs : s = S) : S.copy s hs = S 
goal: S.copy s hs = S

full_name: AddSubmonoid.zero_mem
code: /-- A submonoid contains the monoid's 1. -/
@[to_additive "An `AddSubmonoid` contains the monoid's 0."]
protected theorem one_mem : (1 : M) ∈ S 
goal: 0 ∈ S

full_name: Submonoid.one_mem
code: /-- A submonoid contains the monoid's 1. -/
@[to_additive "An `AddSubmonoid` contains the monoid's 0."]
protected theorem one_mem : (1 : M) ∈ S 
goal: 1 ∈ S

full_name: AddSubmonoid.add_mem
code: /-- A submonoid is closed under multiplication. -/
@[to_additive "An `AddSubmonoid` is closed under addition."]
protected theorem mul_mem {x y : M} : x ∈ S → y ∈ S → x * y ∈ S 
goal: x ∈ S → y ∈ S → x + y ∈ S

full_name: Submonoid.mul_mem
code: /-- A submonoid is closed under multiplication. -/
@[to_additive "An `AddSubmonoid` is closed under addition."]
protected theorem mul_mem {x y : M} : x ∈ S → y ∈ S → x * y ∈ S 
goal: x ∈ S → y ∈ S → x * y ∈ S

full_name: AddSubmonoid.instTop
code: /-- The submonoid `M` of the monoid `M`. -/
@[to_additive "The additive submonoid `M` of the `AddMonoid M`."]
instance : Top (Submonoid M) 
goal: Top (AddSubmonoid M)

full_name: Submonoid.instTop
code: /-- The submonoid `M` of the monoid `M`. -/
@[to_additive "The additive submonoid `M` of the `AddMonoid M`."]
instance : Top (Submonoid M) 
goal: Top (Submonoid M)

full_name: Submonoid.instBot
code: /-- The trivial submonoid `{1}` of a monoid `M`. -/
@[to_additive "The trivial `AddSubmonoid` `{0}` of an `AddMonoid` `M`."]
instance : Bot (Submonoid M) 
goal: Bot (Submonoid M)

full_name: AddSubmonoid.instBot
code: /-- The trivial submonoid `{1}` of a monoid `M`. -/
@[to_additive "The trivial `AddSubmonoid` `{0}` of an `AddMonoid` `M`."]
instance : Bot (Submonoid M) 
goal: Bot (AddSubmonoid M)

full_name: Submonoid.instInhabited
code: @[to_additive]
instance : Inhabited (Submonoid M) 
goal: Inhabited (Submonoid M)

full_name: AddSubmonoid.instInhabited
code: @[to_additive]
instance : Inhabited (Submonoid M) 
goal: Inhabited (AddSubmonoid M)

full_name: Submonoid.mem_bot
code: @[to_additive (attr := simp)]
theorem mem_bot {x : M} : x ∈ (⊥ : Submonoid M) ↔ x = 1 
goal: x ∈ ⊥ ↔ x = 1

full_name: AddSubmonoid.mem_bot
code: @[to_additive (attr := simp)]
theorem mem_bot {x : M} : x ∈ (⊥ : Submonoid M) ↔ x = 1 
goal: x ∈ ⊥ ↔ x = 0

full_name: Submonoid.mem_top
code: @[to_additive (attr := simp)]
theorem mem_top (x : M) : x ∈ (⊤ : Submonoid M) 
goal: x ∈ ⊤

full_name: AddSubmonoid.mem_top
code: @[to_additive (attr := simp)]
theorem mem_top (x : M) : x ∈ (⊤ : Submonoid M) 
goal: x ∈ ⊤

full_name: AddSubmonoid.coe_top
code: @[to_additive (attr := simp)]
theorem coe_top : ((⊤ : Submonoid M) : Set M) = Set.univ 
goal: ↑⊤ = Set.univ

full_name: Submonoid.coe_top
code: @[to_additive (attr := simp)]
theorem coe_top : ((⊤ : Submonoid M) : Set M) = Set.univ 
goal: ↑⊤ = Set.univ

full_name: Submonoid.coe_bot
code: @[to_additive (attr := simp)]
theorem coe_bot : ((⊥ : Submonoid M) : Set M) = {1} 
goal: ↑⊥ = {1}

full_name: AddSubmonoid.coe_bot
code: @[to_additive (attr := simp)]
theorem coe_bot : ((⊥ : Submonoid M) : Set M) = {1} 
goal: ↑⊥ = {0}

full_name: AddSubmonoid.instInf
code: /-- The inf of two submonoids is their intersection. -/
@[to_additive "The inf of two `AddSubmonoid`s is their intersection."]
instance : Inf (Submonoid M) 
goal: Inf (AddSubmonoid M)

full_name: Submonoid.instInf
code: /-- The inf of two submonoids is their intersection. -/
@[to_additive "The inf of two `AddSubmonoid`s is their intersection."]
instance : Inf (Submonoid M) 
goal: Inf (Submonoid M)

full_name: Submonoid.coe_inf
code: @[to_additive (attr := simp)]
theorem coe_inf (p p' : Submonoid M) : ((p ⊓ p' : Submonoid M) : Set M) = (p : Set M) ∩ p' 
goal: ↑(p ⊓ p') = ↑p ∩ ↑p'

full_name: AddSubmonoid.coe_inf
code: @[to_additive (attr := simp)]
theorem coe_inf (p p' : Submonoid M) : ((p ⊓ p' : Submonoid M) : Set M) = (p : Set M) ∩ p' 
goal: ↑(p ⊓ p') = ↑p ∩ ↑p'

full_name: AddSubmonoid.mem_inf
code: @[to_additive (attr := simp)]
theorem mem_inf {p p' : Submonoid M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'

full_name: Submonoid.mem_inf
code: @[to_additive (attr := simp)]
theorem mem_inf {p p' : Submonoid M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'

full_name: AddSubmonoid.instInfSet
code: @[to_additive]
instance : InfSet (Submonoid M) 
goal: InfSet (AddSubmonoid M)

full_name: Submonoid.instInfSet
code: @[to_additive]
instance : InfSet (Submonoid M) 
goal: InfSet (Submonoid M)

full_name: Submonoid.coe_sInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_sInf (S : Set (Submonoid M)) : ((sInf S : Submonoid M) : Set M) = ⋂ s ∈ S, ↑s 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: AddSubmonoid.coe_sInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_sInf (S : Set (Submonoid M)) : ((sInf S : Submonoid M) : Set M) = ⋂ s ∈ S, ↑s 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: AddSubmonoid.mem_sInf
code: @[to_additive]
theorem mem_sInf {S : Set (Submonoid M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p

full_name: Submonoid.mem_sInf
code: @[to_additive]
theorem mem_sInf {S : Set (Submonoid M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p

full_name: AddSubmonoid.mem_iInf
code: @[to_additive]
theorem mem_iInf {ι : Sort*} {S : ι → Submonoid M} {x : M} : (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i

full_name: Submonoid.mem_iInf
code: @[to_additive]
theorem mem_iInf {ι : Sort*} {S : ι → Submonoid M} {x : M} : (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i

full_name: AddSubmonoid.coe_iInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} {S : ι → Submonoid M} : (↑(⨅ i, S i) : Set M) = ⋂ i, S i 
goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)

full_name: Submonoid.coe_iInf
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} {S : ι → Submonoid M} : (↑(⨅ i, S i) : Set M) = ⋂ i, S i 
goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)

full_name: Submonoid.instCompleteLattice
code: /-- Submonoids of a monoid form a complete lattice. -/
@[to_additive "The `AddSubmonoid`s of an `AddMonoid` form a complete lattice."]
instance : CompleteLattice (Submonoid M) 
goal: CompleteLattice (Submonoid M)

full_name: AddSubmonoid.instCompleteLattice
code: /-- Submonoids of a monoid form a complete lattice. -/
@[to_additive "The `AddSubmonoid`s of an `AddMonoid` form a complete lattice."]
instance : CompleteLattice (Submonoid M) 
goal: CompleteLattice (AddSubmonoid M)

full_name: Submonoid.subsingleton_iff
code: @[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Submonoid M) ↔ Subsingleton M 
goal: Subsingleton (Submonoid M) ↔ Subsingleton M

full_name: AddSubmonoid.subsingleton_iff
code: @[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Submonoid M) ↔ Subsingleton M 
goal: Subsingleton (AddSubmonoid M) ↔ Subsingleton M

full_name: Submonoid.nontrivial_iff
code: @[to_additive (attr := simp)]
theorem nontrivial_iff : Nontrivial (Submonoid M) ↔ Nontrivial M 
goal: Nontrivial (Submonoid M) ↔ Nontrivial M

full_name: AddSubmonoid.nontrivial_iff
code: @[to_additive (attr := simp)]
theorem nontrivial_iff : Nontrivial (Submonoid M) ↔ Nontrivial M 
goal: Nontrivial (AddSubmonoid M) ↔ Nontrivial M

full_name: AddSubmonoid.instUniqueOfSubsingleton
code: @[to_additive]
instance [Subsingleton M] : Unique (Submonoid M) 
goal: Unique (AddSubmonoid M)

full_name: Submonoid.instUniqueOfSubsingleton
code: @[to_additive]
instance [Subsingleton M] : Unique (Submonoid M) 
goal: Unique (Submonoid M)

full_name: AddSubmonoid.instNontrivial
code: @[to_additive]
instance [Nontrivial M] : Nontrivial (Submonoid M) 
goal: Nontrivial (AddSubmonoid M)

full_name: Submonoid.instNontrivial
code: @[to_additive]
instance [Nontrivial M] : Nontrivial (Submonoid M) 
goal: Nontrivial (Submonoid M)

full_name: Submonoid.closure
code: /-- The `Submonoid` generated by a set. -/
@[to_additive "The `AddSubmonoid` generated by a set"]
def closure (s : Set M) : Submonoid M 
goal: Submonoid M

full_name: AddSubmonoid.closure
code: /-- The `Submonoid` generated by a set. -/
@[to_additive "The `AddSubmonoid` generated by a set"]
def closure (s : Set M) : Submonoid M 
goal: AddSubmonoid M

full_name: AddSubmonoid.mem_closure
code: @[to_additive]
theorem mem_closure {x : M} : x ∈ closure s ↔ ∀ S : Submonoid M, s ⊆ S → x ∈ S 
goal: x ∈ AddSubmonoid.closure s ↔ ∀ (S : AddSubmonoid M), s ⊆ ↑S → x ∈ S

full_name: Submonoid.mem_closure
code: @[to_additive]
theorem mem_closure {x : M} : x ∈ closure s ↔ ∀ S : Submonoid M, s ⊆ S → x ∈ S 
goal: x ∈ Submonoid.closure s ↔ ∀ (S : Submonoid M), s ⊆ ↑S → x ∈ S

full_name: Submonoid.subset_closure
code: /-- The submonoid generated by a set includes the set. -/
@[to_additive (attr := simp, aesop safe 20 apply (rule_sets := [SetLike]))
  "The `AddSubmonoid` generated by a set includes the set."]
theorem subset_closure : s ⊆ closure s 
goal: s ⊆ ↑(Submonoid.closure s)

full_name: AddSubmonoid.subset_closure
code: /-- The submonoid generated by a set includes the set. -/
@[to_additive (attr := simp, aesop safe 20 apply (rule_sets := [SetLike]))
  "The `AddSubmonoid` generated by a set includes the set."]
theorem subset_closure : s ⊆ closure s 
goal: s ⊆ ↑(AddSubmonoid.closure s)

full_name: AddSubmonoid.not_mem_of_not_mem_closure
code: @[to_additive]
theorem not_mem_of_not_mem_closure {P : M} (hP : P ∉ closure s) : P ∉ s 
goal: P ∉ s

full_name: Submonoid.not_mem_of_not_mem_closure
code: @[to_additive]
theorem not_mem_of_not_mem_closure {P : M} (hP : P ∉ closure s) : P ∉ s 
goal: P ∉ s

full_name: Submonoid.closure_le
code: /-- A submonoid `S` includes `closure s` if and only if it includes `s`. -/
@[to_additive (attr := simp)
"An additive submonoid `S` includes `closure s` if and only if it includes `s`"]
theorem closure_le : closure s ≤ S ↔ s ⊆ S 
goal: Submonoid.closure s ≤ S ↔ s ⊆ ↑S

full_name: AddSubmonoid.closure_le
code: /-- A submonoid `S` includes `closure s` if and only if it includes `s`. -/
@[to_additive (attr := simp)
"An additive submonoid `S` includes `closure s` if and only if it includes `s`"]
theorem closure_le : closure s ≤ S ↔ s ⊆ S 
goal: AddSubmonoid.closure s ≤ S ↔ s ⊆ ↑S

full_name: AddSubmonoid.closure_mono
code: /-- Submonoid closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`. -/
@[to_additive
      "Additive submonoid closure of a set is monotone in its argument: if `s ⊆ t`,
      then `closure s ≤ closure t`"]
theorem closure_mono ⦃s t : Set M⦄ (h : s ⊆ t) : closure s ≤ closure t 
goal: AddSubmonoid.closure s ≤ AddSubmonoid.closure t

full_name: Submonoid.closure_mono
code: /-- Submonoid closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`. -/
@[to_additive
      "Additive submonoid closure of a set is monotone in its argument: if `s ⊆ t`,
      then `closure s ≤ closure t`"]
theorem closure_mono ⦃s t : Set M⦄ (h : s ⊆ t) : closure s ≤ closure t 
goal: Submonoid.closure s ≤ Submonoid.closure t

full_name: Submonoid.closure_eq_of_le
code: @[to_additive]
theorem closure_eq_of_le (h₁ : s ⊆ S) (h₂ : S ≤ closure s) : closure s = S 
goal: Submonoid.closure s = S

full_name: AddSubmonoid.closure_eq_of_le
code: @[to_additive]
theorem closure_eq_of_le (h₁ : s ⊆ S) (h₂ : S ≤ closure s) : closure s = S 
goal: AddSubmonoid.closure s = S

full_name: AddSubmonoid.closure_induction
code: /-- An induction principle for closure membership. If `p` holds for `1` and all elements of `s`, and
is preserved under multiplication, then `p` holds for all elements of the closure of `s`. -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership. If `p` holds for `0` and all
      elements of `s`, and is preserved under addition, then `p` holds for all elements of the
      additive closure of `s`."]
theorem closure_induction {p : M → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x) (one : p 1)
    (mul : ∀ x y, p x → p y → p (x * y)) : p x 
goal: p x

full_name: Submonoid.closure_induction
code: /-- An induction principle for closure membership. If `p` holds for `1` and all elements of `s`, and
is preserved under multiplication, then `p` holds for all elements of the closure of `s`. -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership. If `p` holds for `0` and all
      elements of `s`, and is preserved under addition, then `p` holds for all elements of the
      additive closure of `s`."]
theorem closure_induction {p : M → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x) (one : p 1)
    (mul : ∀ x y, p x → p y → p (x * y)) : p x 
goal: p x

full_name: AddSubmonoid.closure_induction'
code: /-- A dependent version of `Submonoid.closure_induction`.  -/
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.closure_induction`. "]
theorem closure_induction' (s : Set M) {p : ∀ x, x ∈ closure s → Prop}
    (mem : ∀ (x) (h : x ∈ s), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy)) {x} (hx : x ∈ closure s) :
    p x hx 
goal: p x hx

full_name: Submonoid.closure_induction'
code: /-- A dependent version of `Submonoid.closure_induction`.  -/
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.closure_induction`. "]
theorem closure_induction' (s : Set M) {p : ∀ x, x ∈ closure s → Prop}
    (mem : ∀ (x) (h : x ∈ s), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy)) {x} (hx : x ∈ closure s) :
    p x hx 
goal: p x hx

full_name: Submonoid.closure_induction₂
code: /-- An induction principle for closure membership for predicates with two arguments.  -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership for predicates with two arguments."]
theorem closure_induction₂ {p : M → M → Prop} {x} {y : M} (hx : x ∈ closure s) (hy : y ∈ closure s)
    (Hs : ∀ x ∈ s, ∀ y ∈ s, p x y) (H1_left : ∀ x, p 1 x) (H1_right : ∀ x, p x 1)
    (Hmul_left : ∀ x y z, p x z → p y z → p (x * y) z)
    (Hmul_right : ∀ x y z, p z x → p z y → p z (x * y)) : p x y 
goal: p x y

full_name: AddSubmonoid.closure_induction₂
code: /-- An induction principle for closure membership for predicates with two arguments.  -/
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership for predicates with two arguments."]
theorem closure_induction₂ {p : M → M → Prop} {x} {y : M} (hx : x ∈ closure s) (hy : y ∈ closure s)
    (Hs : ∀ x ∈ s, ∀ y ∈ s, p x y) (H1_left : ∀ x, p 1 x) (H1_right : ∀ x, p x 1)
    (Hmul_left : ∀ x y z, p x z → p y z → p (x * y) z)
    (Hmul_right : ∀ x y z, p z x → p z y → p z (x * y)) : p x y 
goal: p x y

full_name: AddSubmonoid.dense_induction
code: /-- If `s` is a dense set in a monoid `M`, `Submonoid.closure s = ⊤`, then in order to prove that
some predicate `p` holds for all `x : M` it suffices to verify `p x` for `x ∈ s`, verify `p 1`,
and verify that `p x` and `p y` imply `p (x * y)`. -/
@[to_additive (attr := elab_as_elim)
      "If `s` is a dense set in an additive monoid `M`, `AddSubmonoid.closure s = ⊤`, then in
      order to prove that some predicate `p` holds for all `x : M` it suffices to verify `p x` for
      `x ∈ s`, verify `p 0`, and verify that `p x` and `p y` imply `p (x + y)`."]
theorem dense_induction {p : M → Prop} (x : M) {s : Set M} (hs : closure s = ⊤)
    (mem : ∀ x ∈ s, p x)
    (one : p 1) (mul : ∀ x y, p x → p y → p (x * y)) : p x 
goal: p x

full_name: Submonoid.dense_induction
code: /-- If `s` is a dense set in a monoid `M`, `Submonoid.closure s = ⊤`, then in order to prove that
some predicate `p` holds for all `x : M` it suffices to verify `p x` for `x ∈ s`, verify `p 1`,
and verify that `p x` and `p y` imply `p (x * y)`. -/
@[to_additive (attr := elab_as_elim)
      "If `s` is a dense set in an additive monoid `M`, `AddSubmonoid.closure s = ⊤`, then in
      order to prove that some predicate `p` holds for all `x : M` it suffices to verify `p x` for
      `x ∈ s`, verify `p 0`, and verify that `p x` and `p y` imply `p (x + y)`."]
theorem dense_induction {p : M → Prop} (x : M) {s : Set M} (hs : closure s = ⊤)
    (mem : ∀ x ∈ s, p x)
    (one : p 1) (mul : ∀ x y, p x → p y → p (x * y)) : p x 
goal: p x

full_name: Submonoid.closure_eq_one_union
code: /-- The `Submonoid.closure` of a set is the union of `{1}` and its `Subsemigroup.closure`. -/
lemma closure_eq_one_union (s : Set M) :
    closure s = {(1 : M)} ∪ (Subsemigroup.closure s : Set M) 
goal: ↑(Submonoid.closure s) = {1} ∪ ↑(Subsemigroup.closure s)

full_name: AddSubmonoid.gi
code: /-- `closure` forms a Galois insertion with the coercion to set. -/
@[to_additive "`closure` forms a Galois insertion with the coercion to set."]
protected def gi : GaloisInsertion (@closure M _) SetLike.coe 
goal: GaloisInsertion AddSubmonoid.closure SetLike.coe

full_name: Submonoid.gi
code: /-- `closure` forms a Galois insertion with the coercion to set. -/
@[to_additive "`closure` forms a Galois insertion with the coercion to set."]
protected def gi : GaloisInsertion (@closure M _) SetLike.coe 
goal: GaloisInsertion Submonoid.closure SetLike.coe

full_name: Submonoid.closure_eq
code: /-- Closure of a submonoid `S` equals `S`. -/
@[to_additive (attr := simp) "Additive closure of an additive submonoid `S` equals `S`"]
theorem closure_eq : closure (S : Set M) = S 
goal: Submonoid.closure ↑S = S

full_name: AddSubmonoid.closure_eq
code: /-- Closure of a submonoid `S` equals `S`. -/
@[to_additive (attr := simp) "Additive closure of an additive submonoid `S` equals `S`"]
theorem closure_eq : closure (S : Set M) = S 
goal: AddSubmonoid.closure ↑S = S

full_name: Submonoid.closure_empty
code: @[to_additive (attr := simp)]
theorem closure_empty : closure (∅ : Set M) = ⊥ 
goal: Submonoid.closure ∅ = ⊥

full_name: AddSubmonoid.closure_empty
code: @[to_additive (attr := simp)]
theorem closure_empty : closure (∅ : Set M) = ⊥ 
goal: AddSubmonoid.closure ∅ = ⊥

full_name: Submonoid.closure_univ
code: @[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set M) = ⊤ 
goal: Submonoid.closure Set.univ = ⊤

full_name: AddSubmonoid.closure_univ
code: @[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set M) = ⊤ 
goal: AddSubmonoid.closure Set.univ = ⊤

full_name: Submonoid.closure_union
code: @[to_additive]
theorem closure_union (s t : Set M) : closure (s ∪ t) = closure s ⊔ closure t 
goal: Submonoid.closure (s ∪ t) = Submonoid.closure s ⊔ Submonoid.closure t

full_name: AddSubmonoid.closure_union
code: @[to_additive]
theorem closure_union (s t : Set M) : closure (s ∪ t) = closure s ⊔ closure t 
goal: AddSubmonoid.closure (s ∪ t) = AddSubmonoid.closure s ⊔ AddSubmonoid.closure t

full_name: Submonoid.sup_eq_closure
code: @[to_additive]
theorem sup_eq_closure (N N' : Submonoid M) : N ⊔ N' = closure ((N : Set M) ∪ (N' : Set M)) 
goal: N ⊔ N' = Submonoid.closure (↑N ∪ ↑N')

full_name: AddSubmonoid.sup_eq_closure
code: @[to_additive]
theorem sup_eq_closure (N N' : Submonoid M) : N ⊔ N' = closure ((N : Set M) ∪ (N' : Set M)) 
goal: N ⊔ N' = AddSubmonoid.closure (↑N ∪ ↑N')

full_name: AddSubmonoid.closure_iUnion
code: @[to_additive]
theorem closure_iUnion {ι} (s : ι → Set M) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
goal: AddSubmonoid.closure (⋃ i, s i) = ⨆ i, AddSubmonoid.closure (s i)

full_name: Submonoid.closure_iUnion
code: @[to_additive]
theorem closure_iUnion {ι} (s : ι → Set M) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
goal: Submonoid.closure (⋃ i, s i) = ⨆ i, Submonoid.closure (s i)

full_name: AddSubmonoid.closure_singleton_le_iff_mem
code: @[to_additive]
theorem closure_singleton_le_iff_mem (m : M) (p : Submonoid M) : closure {m} ≤ p ↔ m ∈ p 
goal: AddSubmonoid.closure {m} ≤ p ↔ m ∈ p

full_name: Submonoid.closure_singleton_le_iff_mem
code: @[to_additive]
theorem closure_singleton_le_iff_mem (m : M) (p : Submonoid M) : closure {m} ≤ p ↔ m ∈ p 
goal: Submonoid.closure {m} ≤ p ↔ m ∈ p

full_name: AddSubmonoid.mem_iSup
code: @[to_additive]
theorem mem_iSup {ι : Sort*} (p : ι → Submonoid M) {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∀ N, (∀ i, p i ≤ N) → m ∈ N 
goal: m ∈ ⨆ i, p i ↔ ∀ (N : AddSubmonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N

full_name: Submonoid.mem_iSup
code: @[to_additive]
theorem mem_iSup {ι : Sort*} (p : ι → Submonoid M) {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∀ N, (∀ i, p i ≤ N) → m ∈ N 
goal: m ∈ ⨆ i, p i ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N

full_name: Submonoid.iSup_eq_closure
code: @[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Submonoid M) :
    ⨆ i, p i = Submonoid.closure (⋃ i, (p i : Set M)) 
goal: ⨆ i, p i = Submonoid.closure (⋃ i, ↑(p i))

full_name: AddSubmonoid.iSup_eq_closure
code: @[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Submonoid M) :
    ⨆ i, p i = Submonoid.closure (⋃ i, (p i : Set M)) 
goal: ⨆ i, p i = AddSubmonoid.closure (⋃ i, ↑(p i))

full_name: AddSubmonoid.disjoint_def
code: @[to_additive]
theorem disjoint_def {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 1 
goal: Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 0

full_name: Submonoid.disjoint_def
code: @[to_additive]
theorem disjoint_def {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 1 
goal: Disjoint p₁ p₂ ↔ ∀ {x : M}, x ∈ p₁ → x ∈ p₂ → x = 1

full_name: Submonoid.disjoint_def'
code: @[to_additive]
theorem disjoint_def' {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1 
goal: Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1

full_name: AddSubmonoid.disjoint_def'
code: @[to_additive]
theorem disjoint_def' {p₁ p₂ : Submonoid M} :
    Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 1 
goal: Disjoint p₁ p₂ ↔ ∀ {x y : M}, x ∈ p₁ → y ∈ p₂ → x = y → x = 0

full_name: MonoidHom.eqLocusM
code: /-- The submonoid of elements `x : M` such that `f x = g x` -/
@[to_additive "The additive submonoid of elements `x : M` such that `f x = g x`"]
def eqLocusM (f g : M →* N) : Submonoid M 
goal: Submonoid M

full_name: AddMonoidHom.eqLocusM
code: /-- The submonoid of elements `x : M` such that `f x = g x` -/
@[to_additive "The additive submonoid of elements `x : M` such that `f x = g x`"]
def eqLocusM (f g : M →* N) : Submonoid M 
goal: AddSubmonoid M

full_name: AddMonoidHom.eqLocusM_same
code: @[to_additive (attr := simp)]
theorem eqLocusM_same (f : M →* N) : f.eqLocusM f = ⊤ 
goal: f.eqLocusM f = ⊤

full_name: MonoidHom.eqLocusM_same
code: @[to_additive (attr := simp)]
theorem eqLocusM_same (f : M →* N) : f.eqLocusM f = ⊤ 
goal: f.eqLocusM f = ⊤

full_name: AddMonoidHom.eqOn_closureM
code: /-- If two monoid homomorphisms are equal on a set, then they are equal on its submonoid closure. -/
@[to_additive
      "If two monoid homomorphisms are equal on a set, then they are equal on its submonoid
      closure."]
theorem eqOn_closureM {f g : M →* N} {s : Set M} (h : Set.EqOn f g s) : Set.EqOn f g (closure s) 
goal: Set.EqOn ⇑f ⇑g ↑(AddSubmonoid.closure s)

full_name: MonoidHom.eqOn_closureM
code: /-- If two monoid homomorphisms are equal on a set, then they are equal on its submonoid closure. -/
@[to_additive
      "If two monoid homomorphisms are equal on a set, then they are equal on its submonoid
      closure."]
theorem eqOn_closureM {f g : M →* N} {s : Set M} (h : Set.EqOn f g s) : Set.EqOn f g (closure s) 
goal: Set.EqOn ⇑f ⇑g ↑(Submonoid.closure s)

full_name: AddMonoidHom.eq_of_eqOn_topM
code: @[to_additive]
theorem eq_of_eqOn_topM {f g : M →* N} (h : Set.EqOn f g (⊤ : Submonoid M)) : f = g 
goal: f = g

full_name: MonoidHom.eq_of_eqOn_topM
code: @[to_additive]
theorem eq_of_eqOn_topM {f g : M →* N} (h : Set.EqOn f g (⊤ : Submonoid M)) : f = g 
goal: f = g

full_name: AddMonoidHom.eq_of_eqOn_denseM
code: @[to_additive]
theorem eq_of_eqOn_denseM {s : Set M} (hs : closure s = ⊤) {f g : M →* N} (h : s.EqOn f g) :
    f = g 
goal: f = g

full_name: MonoidHom.eq_of_eqOn_denseM
code: @[to_additive]
theorem eq_of_eqOn_denseM {s : Set M} (hs : closure s = ⊤) {f g : M →* N} (h : s.EqOn f g) :
    f = g 
goal: f = g

full_name: IsAddUnit.addSubmonoid
code: /-- The submonoid consisting of the units of a monoid -/
@[to_additive "The additive submonoid consisting of the additive units of an additive monoid"]
def IsUnit.submonoid (M : Type*) [Monoid M] : Submonoid M 
goal: AddSubmonoid M

full_name: IsUnit.submonoid
code: /-- The submonoid consisting of the units of a monoid -/
@[to_additive "The additive submonoid consisting of the additive units of an additive monoid"]
def IsUnit.submonoid (M : Type*) [Monoid M] : Submonoid M 
goal: Submonoid M

full_name: IsAddUnit.mem_addSubmonoid_iff
code: @[to_additive]
theorem IsUnit.mem_submonoid_iff {M : Type*} [Monoid M] (a : M) :
    a ∈ IsUnit.submonoid M ↔ IsUnit a 
goal: a ∈ IsAddUnit.addSubmonoid M ↔ IsAddUnit a

full_name: IsUnit.mem_submonoid_iff
code: @[to_additive]
theorem IsUnit.mem_submonoid_iff {M : Type*} [Monoid M] (a : M) :
    a ∈ IsUnit.submonoid M ↔ IsUnit a 
goal: a ∈ IsUnit.submonoid M ↔ IsUnit a

full_name: MonoidHom.ofClosureMEqTopLeft
code: /-- Let `s` be a subset of a monoid `M` such that the closure of `s` is the whole monoid.
Then `MonoidHom.ofClosureEqTopLeft` defines a monoid homomorphism from `M` asking for
a proof of `f (x * y) = f x * f y` only for `x ∈ s`. -/
@[to_additive
      "Let `s` be a subset of an additive monoid `M` such that the closure of `s` is
      the whole monoid. Then `AddMonoidHom.ofClosureEqTopLeft` defines an additive monoid
      homomorphism from `M` asking for a proof of `f (x + y) = f x + f y` only for `x ∈ s`. "]
def ofClosureMEqTopLeft {M N} [Monoid M] [Monoid N] {s : Set M} (f : M → N) (hs : closure s = ⊤)
    (h1 : f 1 = 1) (hmul : ∀ x ∈ s, ∀ (y), f (x * y) = f x * f y) :
    M →* N 
goal: M →* N

full_name: AddMonoidHom.ofClosureMEqTopLeft
code: /-- Let `s` be a subset of a monoid `M` such that the closure of `s` is the whole monoid.
Then `MonoidHom.ofClosureEqTopLeft` defines a monoid homomorphism from `M` asking for
a proof of `f (x * y) = f x * f y` only for `x ∈ s`. -/
@[to_additive
      "Let `s` be a subset of an additive monoid `M` such that the closure of `s` is
      the whole monoid. Then `AddMonoidHom.ofClosureEqTopLeft` defines an additive monoid
      homomorphism from `M` asking for a proof of `f (x + y) = f x + f y` only for `x ∈ s`. "]
def ofClosureMEqTopLeft {M N} [Monoid M] [Monoid N] {s : Set M} (f : M → N) (hs : closure s = ⊤)
    (h1 : f 1 = 1) (hmul : ∀ x ∈ s, ∀ (y), f (x * y) = f x * f y) :
    M →* N 
goal: M →+ N

full_name: MonoidHom.coe_ofClosureMEqTopLeft
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopLeft (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopLeft f hs h1 hmul) = f 
goal: ⇑(MonoidHom.ofClosureMEqTopLeft f hs h1 hmul) = f

full_name: AddMonoidHom.coe_ofClosureMEqTopLeft
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopLeft (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopLeft f hs h1 hmul) = f 
goal: ⇑(AddMonoidHom.ofClosureMEqTopLeft f hs h1 hmul) = f

full_name: MonoidHom.ofClosureMEqTopRight
code: /-- Let `s` be a subset of a monoid `M` such that the closure of `s` is the whole monoid.
Then `MonoidHom.ofClosureEqTopRight` defines a monoid homomorphism from `M` asking for
a proof of `f (x * y) = f x * f y` only for `y ∈ s`. -/
@[to_additive
      "Let `s` be a subset of an additive monoid `M` such that the closure of `s` is
      the whole monoid. Then `AddMonoidHom.ofClosureEqTopRight` defines an additive monoid
      homomorphism from `M` asking for a proof of `f (x + y) = f x + f y` only for `y ∈ s`. "]
def ofClosureMEqTopRight {M N} [Monoid M] [Monoid N] {s : Set M} (f : M → N) (hs : closure s = ⊤)
    (h1 : f 1 = 1) (hmul : ∀ (x), ∀ y ∈ s, f (x * y) = f x * f y) :
    M →* N 
goal: M →* N

full_name: AddMonoidHom.ofClosureMEqTopRight
code: /-- Let `s` be a subset of a monoid `M` such that the closure of `s` is the whole monoid.
Then `MonoidHom.ofClosureEqTopRight` defines a monoid homomorphism from `M` asking for
a proof of `f (x * y) = f x * f y` only for `y ∈ s`. -/
@[to_additive
      "Let `s` be a subset of an additive monoid `M` such that the closure of `s` is
      the whole monoid. Then `AddMonoidHom.ofClosureEqTopRight` defines an additive monoid
      homomorphism from `M` asking for a proof of `f (x + y) = f x + f y` only for `y ∈ s`. "]
def ofClosureMEqTopRight {M N} [Monoid M] [Monoid N] {s : Set M} (f : M → N) (hs : closure s = ⊤)
    (h1 : f 1 = 1) (hmul : ∀ (x), ∀ y ∈ s, f (x * y) = f x * f y) :
    M →* N 
goal: M →+ N

full_name: MonoidHom.coe_ofClosureMEqTopRight
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopRight (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopRight f hs h1 hmul) = f 
goal: ⇑(MonoidHom.ofClosureMEqTopRight f hs h1 hmul) = f

full_name: AddMonoidHom.coe_ofClosureMEqTopRight
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_ofClosureMEqTopRight (f : M → N) (hs : closure s = ⊤) (h1 hmul) :
    ⇑(ofClosureMEqTopRight f hs h1 hmul) = f 
goal: ⇑(AddMonoidHom.ofClosureMEqTopRight f hs h1 hmul) = f