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

full_name: AddSubmonoid.add_subset
code: @[to_additive]
theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S 
goal: s + t ⊆ ↑S

full_name: Submonoid.mul_subset
code: @[to_additive]
theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S 
goal: s * t ⊆ ↑S

full_name: AddSubmonoid.add_subset_closure
code: @[to_additive]
theorem mul_subset_closure (hs : s ⊆ u) (ht : t ⊆ u) : s * t ⊆ Submonoid.closure u 
goal: s + t ⊆ ↑(AddSubmonoid.closure u)

full_name: Submonoid.mul_subset_closure
code: @[to_additive]
theorem mul_subset_closure (hs : s ⊆ u) (ht : t ⊆ u) : s * t ⊆ Submonoid.closure u 
goal: s * t ⊆ ↑(Submonoid.closure u)

full_name: Submonoid.coe_mul_self_eq
code: @[to_additive]
theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s 
goal: ↑s * ↑s = ↑s

full_name: AddSubmonoid.coe_add_self_eq
code: @[to_additive]
theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s 
goal: ↑s + ↑s = ↑s

full_name: AddSubmonoid.closure_add_le
code: @[to_additive]
theorem closure_mul_le (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.closure_mul_le
code: @[to_additive]
theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T 
goal: Submonoid.closure (S * T) ≤ Submonoid.closure S ⊔ Submonoid.closure T

full_name: Submonoid.sup_eq_closure_mul
code: @[to_additive]
theorem sup_eq_closure_mul (H K : Submonoid M) : H ⊔ K = closure ((H : Set M) * (K : Set M)) 
goal: H ⊔ K = Submonoid.closure (↑H * ↑K)

full_name: AddSubmonoid.sup_eq_closure_add
code: @[to_additive]
theorem sup_eq_closure_mul (H K : Submonoid M) : H ⊔ K = closure ((H : Set M) * (K : Set M)) 
goal: H ⊔ K = AddSubmonoid.closure (↑H + ↑K)

full_name: AddSubmonoid.nsmul_vadd_mem_closure_vadd
code: @[to_additive]
theorem pow_smul_mem_closure_smul {N : Type*} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]
    (r : M) (s : Set N) {x : N} (hx : x ∈ closure s) : ∃ n : ℕ, r ^ n • x ∈ closure (r • s) 
goal: ∃ n, n • r +ᵥ x ∈ AddSubmonoid.closure (r +ᵥ s)

full_name: Submonoid.pow_smul_mem_closure_smul
code: @[to_additive]
theorem pow_smul_mem_closure_smul {N : Type*} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]
    (r : M) (s : Set N) {x : N} (hx : x ∈ closure s) : ∃ n : ℕ, r ^ n • x ∈ closure (r • s) 
goal: ∃ n, r ^ n • x ∈ Submonoid.closure (r • s)

full_name: Submonoid.inv
code: /-- The submonoid with every element inverted. -/
@[to_additive " The additive submonoid with every element negated. "]
protected def inv : Inv (Submonoid G) 
goal: Inv (Submonoid G)

full_name: AddSubmonoid.neg
code: /-- The submonoid with every element inverted. -/
@[to_additive " The additive submonoid with every element negated. "]
protected def inv : Inv (Submonoid G) 
goal: Neg (AddSubmonoid G)

full_name: Submonoid.coe_inv
code: @[to_additive (attr := simp)]
theorem coe_inv (S : Submonoid G) : ↑S⁻¹ = (S : Set G)⁻¹ 
goal: ↑S⁻¹ = (↑S)⁻¹

full_name: AddSubmonoid.coe_neg
code: @[to_additive (attr := simp)]
theorem coe_inv (S : Submonoid G) : ↑S⁻¹ = (S : Set G)⁻¹ 
goal: ↑(-S) = -↑S

full_name: AddSubmonoid.mem_neg
code: @[to_additive (attr := simp)]
theorem mem_inv {g : G} {S : Submonoid G} : g ∈ S⁻¹ ↔ g⁻¹ ∈ S 
goal: g ∈ -S ↔ -g ∈ S

full_name: Submonoid.mem_inv
code: @[to_additive (attr := simp)]
theorem mem_inv {g : G} {S : Submonoid G} : g ∈ S⁻¹ ↔ g⁻¹ ∈ S 
goal: g ∈ S⁻¹ ↔ g⁻¹ ∈ S

full_name: Submonoid.involutiveInv
code: /-- Inversion is involutive on submonoids. -/
@[to_additive "Inversion is involutive on additive submonoids."]
def involutiveInv : InvolutiveInv (Submonoid G) 
goal: InvolutiveInv (Submonoid G)

full_name: AddSubmonoid.involutiveNeg
code: /-- Inversion is involutive on submonoids. -/
@[to_additive "Inversion is involutive on additive submonoids."]
def involutiveInv : InvolutiveInv (Submonoid G) 
goal: InvolutiveNeg (AddSubmonoid G)

full_name: Submonoid.inv_le_inv
code: @[to_additive (attr := simp)]
theorem inv_le_inv (S T : Submonoid G) : S⁻¹ ≤ T⁻¹ ↔ S ≤ T 
goal: S⁻¹ ≤ T⁻¹ ↔ S ≤ T

full_name: AddSubmonoid.neg_le_neg
code: @[to_additive (attr := simp)]
theorem inv_le_inv (S T : Submonoid G) : S⁻¹ ≤ T⁻¹ ↔ S ≤ T 
goal: -S ≤ -T ↔ S ≤ T

full_name: AddSubmonoid.neg_le
code: @[to_additive]
theorem inv_le (S T : Submonoid G) : S⁻¹ ≤ T ↔ S ≤ T⁻¹ 
goal: -S ≤ T ↔ S ≤ -T

full_name: Submonoid.inv_le
code: @[to_additive]
theorem inv_le (S T : Submonoid G) : S⁻¹ ≤ T ↔ S ≤ T⁻¹ 
goal: S⁻¹ ≤ T ↔ S ≤ T⁻¹

full_name: AddSubmonoid.negOrderIso_symm_apply_coe
code: /-- Pointwise inversion of submonoids as an order isomorphism. -/
@[to_additive (attr := simps!) "Pointwise negation of additive submonoids as an order isomorphism"]
def invOrderIso : Submonoid G ≃o Submonoid G 
goal: ∀ (a : AddSubmonoid G), ↑((RelIso.symm AddSubmonoid.negOrderIso) a) = -↑a

full_name: Submonoid.invOrderIso_apply_coe
code: /-- Pointwise inversion of submonoids as an order isomorphism. -/
@[to_additive (attr := simps!) "Pointwise negation of additive submonoids as an order isomorphism"]
def invOrderIso : Submonoid G ≃o Submonoid G 
goal: ∀ (a : Submonoid G), ↑(Submonoid.invOrderIso a) = (↑a)⁻¹

full_name: Submonoid.invOrderIso_symm_apply_coe
code: /-- Pointwise inversion of submonoids as an order isomorphism. -/
@[to_additive (attr := simps!) "Pointwise negation of additive submonoids as an order isomorphism"]
def invOrderIso : Submonoid G ≃o Submonoid G 
goal: ∀ (a : Submonoid G), ↑((RelIso.symm Submonoid.invOrderIso) a) = (↑a)⁻¹

full_name: AddSubmonoid.negOrderIso
code: /-- Pointwise inversion of submonoids as an order isomorphism. -/
@[to_additive (attr := simps!) "Pointwise negation of additive submonoids as an order isomorphism"]
def invOrderIso : Submonoid G ≃o Submonoid G 
goal: AddSubmonoid G ≃o AddSubmonoid G

full_name: AddSubmonoid.negOrderIso_apply_coe
code: /-- Pointwise inversion of submonoids as an order isomorphism. -/
@[to_additive (attr := simps!) "Pointwise negation of additive submonoids as an order isomorphism"]
def invOrderIso : Submonoid G ≃o Submonoid G 
goal: ∀ (a : AddSubmonoid G), ↑(AddSubmonoid.negOrderIso a) = -↑a

full_name: Submonoid.invOrderIso
code: /-- Pointwise inversion of submonoids as an order isomorphism. -/
@[to_additive (attr := simps!) "Pointwise negation of additive submonoids as an order isomorphism"]
def invOrderIso : Submonoid G ≃o Submonoid G 
goal: Submonoid G ≃o Submonoid G

full_name: AddSubmonoid.closure_neg
code: @[to_additive]
theorem closure_inv (s : Set G) : closure s⁻¹ = (closure s)⁻¹ 
goal: AddSubmonoid.closure (-s) = -AddSubmonoid.closure s

full_name: Submonoid.closure_inv
code: @[to_additive]
theorem closure_inv (s : Set G) : closure s⁻¹ = (closure s)⁻¹ 
goal: Submonoid.closure s⁻¹ = (Submonoid.closure s)⁻¹

full_name: Submonoid.inv_inf
code: @[to_additive (attr := simp)]
theorem inv_inf (S T : Submonoid G) : (S ⊓ T)⁻¹ = S⁻¹ ⊓ T⁻¹ 
goal: (S ⊓ T)⁻¹ = S⁻¹ ⊓ T⁻¹

full_name: AddSubmonoid.neg_inf
code: @[to_additive (attr := simp)]
theorem inv_inf (S T : Submonoid G) : (S ⊓ T)⁻¹ = S⁻¹ ⊓ T⁻¹ 
goal: -(S ⊓ T) = -S ⊓ -T

full_name: Submonoid.inv_sup
code: @[to_additive (attr := simp)]
theorem inv_sup (S T : Submonoid G) : (S ⊔ T)⁻¹ = S⁻¹ ⊔ T⁻¹ 
goal: (S ⊔ T)⁻¹ = S⁻¹ ⊔ T⁻¹

full_name: AddSubmonoid.neg_sup
code: @[to_additive (attr := simp)]
theorem inv_sup (S T : Submonoid G) : (S ⊔ T)⁻¹ = S⁻¹ ⊔ T⁻¹ 
goal: -(S ⊔ T) = -S ⊔ -T

full_name: Submonoid.inv_bot
code: @[to_additive (attr := simp)]
theorem inv_bot : (⊥ : Submonoid G)⁻¹ = ⊥ 
goal: ⊥⁻¹ = ⊥

full_name: AddSubmonoid.neg_bot
code: @[to_additive (attr := simp)]
theorem inv_bot : (⊥ : Submonoid G)⁻¹ = ⊥ 
goal: -⊥ = ⊥

full_name: AddSubmonoid.neg_top
code: @[to_additive (attr := simp)]
theorem inv_top : (⊤ : Submonoid G)⁻¹ = ⊤ 
goal: -⊤ = ⊤

full_name: Submonoid.inv_top
code: @[to_additive (attr := simp)]
theorem inv_top : (⊤ : Submonoid G)⁻¹ = ⊤ 
goal: ⊤⁻¹ = ⊤

full_name: Submonoid.inv_iInf
code: @[to_additive (attr := simp)]
theorem inv_iInf {ι : Sort*} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ 
goal: (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹

full_name: AddSubmonoid.neg_iInf
code: @[to_additive (attr := simp)]
theorem inv_iInf {ι : Sort*} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ 
goal: -⨅ i, S i = ⨅ i, -S i

full_name: AddSubmonoid.neg_iSup
code: @[to_additive (attr := simp)]
theorem inv_iSup {ι : Sort*} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ 
goal: -⨆ i, S i = ⨆ i, -S i

full_name: Submonoid.inv_iSup
code: @[to_additive (attr := simp)]
theorem inv_iSup {ι : Sort*} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ 
goal: (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹

full_name: Submonoid.pointwiseMulAction
code: /-- The action on a submonoid corresponding to applying the action to every element.

This is available as an instance in the `Pointwise` locale. -/
protected def pointwiseMulAction : MulAction α (Submonoid M) 
goal: MulAction α (Submonoid M)

full_name: Submonoid.coe_pointwise_smul
code: @[simp]
theorem coe_pointwise_smul (a : α) (S : Submonoid M) : ↑(a • S) = a • (S : Set M) 
goal: ↑(a • S) = a • ↑S

full_name: Submonoid.smul_mem_pointwise_smul
code: theorem smul_mem_pointwise_smul (m : M) (a : α) (S : Submonoid M) : m ∈ S → a • m ∈ a • S 
goal: m ∈ S → a • m ∈ a • S

full_name: Submonoid.instCovariantClassHSMulLe
code: instance : CovariantClass α (Submonoid M) HSMul.hSMul LE.le 
goal: CovariantClass α (Submonoid M) HSMul.hSMul LE.le

full_name: Submonoid.mem_smul_pointwise_iff_exists
code: theorem mem_smul_pointwise_iff_exists (m : M) (a : α) (S : Submonoid M) :
    m ∈ a • S ↔ ∃ s : M, s ∈ S ∧ a • s = m 
goal: m ∈ a • S ↔ ∃ s ∈ S, a • s = m

full_name: Submonoid.smul_bot
code: @[simp]
theorem smul_bot (a : α) : a • (⊥ : Submonoid M) = ⊥ 
goal: a • ⊥ = ⊥

full_name: Submonoid.smul_sup
code: theorem smul_sup (a : α) (S T : Submonoid M) : a • (S ⊔ T) = a • S ⊔ a • T 
goal: a • (S ⊔ T) = a • S ⊔ a • T

full_name: Submonoid.smul_closure
code: theorem smul_closure (a : α) (s : Set M) : a • closure s = closure (a • s) 
goal: a • Submonoid.closure s = Submonoid.closure (a • s)

full_name: Submonoid.pointwise_isCentralScalar
code: lemma pointwise_isCentralScalar [MulDistribMulAction αᵐᵒᵖ M] [IsCentralScalar α M] :
    IsCentralScalar α (Submonoid M) 
goal: IsCentralScalar α (Submonoid M)

full_name: Submonoid.smul_mem_pointwise_smul_iff
code: @[simp]
theorem smul_mem_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : a • x ∈ a • S ↔ x ∈ S 
goal: a • x ∈ a • S ↔ x ∈ S

full_name: Submonoid.mem_pointwise_smul_iff_inv_smul_mem
code: theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : Submonoid M} {x : M} :
    x ∈ a • S ↔ a⁻¹ • x ∈ S 
goal: x ∈ a • S ↔ a⁻¹ • x ∈ S

full_name: Submonoid.mem_inv_pointwise_smul_iff
code: theorem mem_inv_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : x ∈ a⁻¹ • S ↔ a • x ∈ S 
goal: x ∈ a⁻¹ • S ↔ a • x ∈ S

full_name: Submonoid.pointwise_smul_le_pointwise_smul_iff
code: @[simp]
theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : Submonoid M} : a • S ≤ a • T ↔ S ≤ T 
goal: a • S ≤ a • T ↔ S ≤ T

full_name: Submonoid.pointwise_smul_subset_iff
code: theorem pointwise_smul_subset_iff {a : α} {S T : Submonoid M} : a • S ≤ T ↔ S ≤ a⁻¹ • T 
goal: a • S ≤ T ↔ S ≤ a⁻¹ • T

full_name: Submonoid.subset_pointwise_smul_iff
code: theorem subset_pointwise_smul_iff {a : α} {S T : Submonoid M} : S ≤ a • T ↔ a⁻¹ • S ≤ T 
goal: S ≤ a • T ↔ a⁻¹ • S ≤ T

full_name: Submonoid.smul_mem_pointwise_smul_iff₀
code: @[simp]
theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
    a • x ∈ a • S ↔ x ∈ S 
goal: a • x ∈ a • S ↔ x ∈ S

full_name: Submonoid.mem_pointwise_smul_iff_inv_smul_mem₀
code: theorem mem_pointwise_smul_iff_inv_smul_mem₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
    x ∈ a • S ↔ a⁻¹ • x ∈ S 
goal: x ∈ a • S ↔ a⁻¹ • x ∈ S

full_name: Submonoid.mem_inv_pointwise_smul_iff₀
code: theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
    x ∈ a⁻¹ • S ↔ a • x ∈ S 
goal: x ∈ a⁻¹ • S ↔ a • x ∈ S

full_name: Submonoid.pointwise_smul_le_pointwise_smul_iff₀
code: @[simp]
theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} :
    a • S ≤ a • T ↔ S ≤ T 
goal: a • S ≤ a • T ↔ S ≤ T

full_name: Submonoid.pointwise_smul_le_iff₀
code: theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : a • S ≤ T ↔ S ≤ a⁻¹ • T 
goal: a • S ≤ T ↔ S ≤ a⁻¹ • T

full_name: Submonoid.le_pointwise_smul_iff₀
code: theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : S ≤ a • T ↔ a⁻¹ • S ≤ T 
goal: S ≤ a • T ↔ a⁻¹ • S ≤ T

full_name: Submonoid.mem_closure_inv
code: @[to_additive]
theorem mem_closure_inv {G : Type*} [Group G] (S : Set G) (x : G) :
    x ∈ Submonoid.closure S⁻¹ ↔ x⁻¹ ∈ Submonoid.closure S 
goal: x ∈ Submonoid.closure S⁻¹ ↔ x⁻¹ ∈ Submonoid.closure S

full_name: AddSubmonoid.mem_closure_neg
code: @[to_additive]
theorem mem_closure_inv {G : Type*} [Group G] (S : Set G) (x : G) :
    x ∈ Submonoid.closure S⁻¹ ↔ x⁻¹ ∈ Submonoid.closure S 
goal: x ∈ AddSubmonoid.closure (-S) ↔ -x ∈ AddSubmonoid.closure S

full_name: AddSubmonoid.pointwiseMulAction
code: /-- The action on an additive submonoid corresponding to applying the action to every element.

This is available as an instance in the `Pointwise` locale. -/
protected def pointwiseMulAction : MulAction α (AddSubmonoid A) 
goal: MulAction α (AddSubmonoid A)

full_name: AddSubmonoid.coe_pointwise_smul
code: @[simp]
theorem coe_pointwise_smul (a : α) (S : AddSubmonoid A) : ↑(a • S) = a • (S : Set A) 
goal: ↑(a • S) = a • ↑S

full_name: AddSubmonoid.smul_mem_pointwise_smul
code: theorem smul_mem_pointwise_smul (m : A) (a : α) (S : AddSubmonoid A) : m ∈ S → a • m ∈ a • S 
goal: m ∈ S → a • m ∈ a • S

full_name: AddSubmonoid.mem_smul_pointwise_iff_exists
code: theorem mem_smul_pointwise_iff_exists (m : A) (a : α) (S : AddSubmonoid A) :
    m ∈ a • S ↔ ∃ s : A, s ∈ S ∧ a • s = m 
goal: m ∈ a • S ↔ ∃ s ∈ S, a • s = m

full_name: AddSubmonoid.smul_bot
code: @[simp]
theorem smul_bot (a : α) : a • (⊥ : AddSubmonoid A) = ⊥ 
goal: a • ⊥ = ⊥

full_name: AddSubmonoid.smul_sup
code: theorem smul_sup (a : α) (S T : AddSubmonoid A) : a • (S ⊔ T) = a • S ⊔ a • T 
goal: a • (S ⊔ T) = a • S ⊔ a • T

full_name: AddSubmonoid.smul_closure
code: @[simp]
theorem smul_closure (a : α) (s : Set A) : a • closure s = closure (a • s) 
goal: a • AddSubmonoid.closure s = AddSubmonoid.closure (a • s)

full_name: AddSubmonoid.pointwise_isCentralScalar
code: lemma pointwise_isCentralScalar [DistribMulAction αᵐᵒᵖ A] [IsCentralScalar α A] :
    IsCentralScalar α (AddSubmonoid A) 
goal: IsCentralScalar α (AddSubmonoid A)

full_name: AddSubmonoid.smul_mem_pointwise_smul_iff
code: @[simp]
theorem smul_mem_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : a • x ∈ a • S ↔ x ∈ S 
goal: a • x ∈ a • S ↔ x ∈ S

full_name: AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem
code: theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : AddSubmonoid A} {x : A} :
    x ∈ a • S ↔ a⁻¹ • x ∈ S 
goal: x ∈ a • S ↔ a⁻¹ • x ∈ S

full_name: AddSubmonoid.mem_inv_pointwise_smul_iff
code: theorem mem_inv_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : x ∈ a⁻¹ • S ↔ a • x ∈ S 
goal: x ∈ a⁻¹ • S ↔ a • x ∈ S

full_name: AddSubmonoid.pointwise_smul_le_pointwise_smul_iff
code: @[simp]
theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} :
    a • S ≤ a • T ↔ S ≤ T 
goal: a • S ≤ a • T ↔ S ≤ T

full_name: AddSubmonoid.pointwise_smul_le_iff
code: theorem pointwise_smul_le_iff {a : α} {S T : AddSubmonoid A} : a • S ≤ T ↔ S ≤ a⁻¹ • T 
goal: a • S ≤ T ↔ S ≤ a⁻¹ • T

full_name: AddSubmonoid.le_pointwise_smul_iff
code: theorem le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} : S ≤ a • T ↔ a⁻¹ • S ≤ T 
goal: S ≤ a • T ↔ a⁻¹ • S ≤ T

full_name: AddSubmonoid.smul_mem_pointwise_smul_iff₀
code: @[simp]
theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
    a • x ∈ a • S ↔ x ∈ S 
goal: a • x ∈ a • S ↔ x ∈ S

full_name: AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem₀
code: theorem mem_pointwise_smul_iff_inv_smul_mem₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
    x ∈ a • S ↔ a⁻¹ • x ∈ S 
goal: x ∈ a • S ↔ a⁻¹ • x ∈ S

full_name: AddSubmonoid.mem_inv_pointwise_smul_iff₀
code: theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
    x ∈ a⁻¹ • S ↔ a • x ∈ S 
goal: x ∈ a⁻¹ • S ↔ a • x ∈ S

full_name: AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀
code: @[simp]
theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
    a • S ≤ a • T ↔ S ≤ T 
goal: a • S ≤ a • T ↔ S ≤ T

full_name: AddSubmonoid.pointwise_smul_le_iff₀
code: theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
    a • S ≤ T ↔ S ≤ a⁻¹ • T 
goal: a • S ≤ T ↔ S ≤ a⁻¹ • T

full_name: AddSubmonoid.le_pointwise_smul_iff₀
code: theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
    S ≤ a • T ↔ a⁻¹ • S ≤ T 
goal: S ≤ a • T ↔ a⁻¹ • S ≤ T

full_name: AddSubmonoid.one
code: /-- If `R` is an additive monoid with one (e.g., a semiring), then `1 : AddSubmonoid R` is the range
of `Nat.cast : ℕ → R`. -/
protected def one : One (AddSubmonoid R) 
goal: One (AddSubmonoid R)

full_name: AddSubmonoid.one_eq_mrange
code: theorem one_eq_mrange : (1 : AddSubmonoid R) = AddMonoidHom.mrange (Nat.castAddMonoidHom R) 
goal: 1 = AddMonoidHom.mrange (Nat.castAddMonoidHom R)

full_name: AddSubmonoid.natCast_mem_one
code: theorem natCast_mem_one (n : ℕ) : (n : R) ∈ (1 : AddSubmonoid R) 
goal: ↑n ∈ 1

full_name: AddSubmonoid.mem_one
code: @[simp]
theorem mem_one {x : R} : x ∈ (1 : AddSubmonoid R) ↔ ∃ n : ℕ, ↑n = x 
goal: x ∈ 1 ↔ ∃ n, ↑n = x

full_name: AddSubmonoid.one_eq_closure
code: theorem one_eq_closure : (1 : AddSubmonoid R) = closure {1} 
goal: 1 = AddSubmonoid.closure {1}

full_name: AddSubmonoid.one_eq_closure_one_set
code: theorem one_eq_closure_one_set : (1 : AddSubmonoid R) = closure 1 
goal: 1 = AddSubmonoid.closure 1

full_name: AddSubmonoid.mul
code: /-- Multiplication of additive submonoids of a semiring R. The additive submonoid `S * T` is the
smallest R-submodule of `R` containing the elements `s * t` for `s ∈ S` and `t ∈ T`. -/
protected def mul : Mul (AddSubmonoid R) 
goal: Mul (AddSubmonoid R)

full_name: AddSubmonoid.mul_mem_mul
code: theorem mul_mem_mul {M N : AddSubmonoid R} {m n : R} (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N 
goal: m * n ∈ M * N

full_name: AddSubmonoid.mul_le
code: theorem mul_le {M N P : AddSubmonoid R} : M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P 
goal: M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P

full_name: AddSubmonoid.mul_induction_on
code: @[elab_as_elim]
protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r : R} (hr : r ∈ M * N)
    (hm : ∀ m ∈ M, ∀ n ∈ N, C (m * n)) (ha : ∀ x y, C x → C y → C (x + y)) : C r 
goal: C r

full_name: AddSubmonoid.closure_mul_closure
code: theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S * T) 
goal: AddSubmonoid.closure S * AddSubmonoid.closure T = AddSubmonoid.closure (S * T)

full_name: AddSubmonoid.mul_eq_closure_mul_set
code: theorem mul_eq_closure_mul_set (M N : AddSubmonoid R) :
    M * N = closure ((M : Set R) * (N : Set R)) 
goal: M * N = AddSubmonoid.closure (↑M * ↑N)

full_name: AddSubmonoid.mul_bot
code: @[simp]
theorem mul_bot (S : AddSubmonoid R) : S * ⊥ = ⊥ 
goal: S * ⊥ = ⊥

full_name: AddSubmonoid.bot_mul
code: @[simp]
theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ 
goal: ⊥ * S = ⊥

full_name: AddSubmonoid.mul_le_mul
code: @[mono]
theorem mul_le_mul {M N P Q : AddSubmonoid R} (hmp : M ≤ P) (hnq : N ≤ Q) : M * N ≤ P * Q 
goal: M * N ≤ P * Q

full_name: AddSubmonoid.mul_le_mul_left
code: theorem mul_le_mul_left {M N P : AddSubmonoid R} (h : M ≤ N) : M * P ≤ N * P 
goal: M * P ≤ N * P

full_name: AddSubmonoid.mul_le_mul_right
code: theorem mul_le_mul_right {M N P : AddSubmonoid R} (h : N ≤ P) : M * N ≤ M * P 
goal: M * N ≤ M * P

full_name: AddSubmonoid.mul_subset_mul
code: theorem mul_subset_mul {M N : AddSubmonoid R} :
    (↑M : Set R) * (↑N : Set R) ⊆ (↑(M * N) : Set R) 
goal: ↑M * ↑N ⊆ ↑(M * N)

full_name: AddSubmonoid.hasDistribNeg
code: /-- `AddSubmonoid.neg` distributes over multiplication.

This is available as an instance in the `Pointwise` locale. -/
protected def hasDistribNeg : HasDistribNeg (AddSubmonoid R) 
goal: HasDistribNeg (AddSubmonoid R)

full_name: AddSubmonoid.mulOneClass
code: /-- A `MulOneClass` structure on additive submonoids of a (possibly, non-associative) semiring. -/
protected def mulOneClass : MulOneClass (AddSubmonoid R) 
goal: MulOneClass (AddSubmonoid R)

full_name: AddSubmonoid.semigroup
code: /-- Semigroup structure on additive submonoids of a (possibly, non-unital) semiring. -/
protected def semigroup : Semigroup (AddSubmonoid R) 
goal: Semigroup (AddSubmonoid R)

full_name: AddSubmonoid.monoid
code: /-- Monoid structure on additive submonoids of a semiring. -/
protected def monoid : Monoid (AddSubmonoid R) 
goal: Monoid (AddSubmonoid R)

full_name: AddSubmonoid.closure_pow
code: theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)
  
goal: AddSubmonoid.closure s ^ n = AddSubmonoid.closure (s ^ n)

full_name: AddSubmonoid.pow_eq_closure_pow_set
code: theorem pow_eq_closure_pow_set (s : AddSubmonoid R) (n : ℕ) :
    s ^ n = closure ((s : Set R) ^ n) 
goal: s ^ n = AddSubmonoid.closure (↑s ^ n)

full_name: AddSubmonoid.pow_subset_pow
code: theorem pow_subset_pow {s : AddSubmonoid R} {n : ℕ} : (↑s : Set R) ^ n ⊆ ↑(s ^ n) 
goal: ↑s ^ n ⊆ ↑(s ^ n)

full_name: Set.IsPWO.submonoid_closure
code: @[to_additive]
theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPWO) :
    IsPWO (Submonoid.closure s : Set α) 
goal: (↑(Submonoid.closure s)).IsPWO

full_name: Set.IsPWO.addSubmonoid_closure
code: @[to_additive]
theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPWO) :
    IsPWO (Submonoid.closure s : Set α) 
goal: (↑(AddSubmonoid.closure s)).IsPWO