Submonoids: membership criteria

In this file we prove various facts about membership in a submonoid:

• list_prod_mem, multiset_prod_mem, prod_mem: if each element of a collection belongs to a multiplicative submonoid, then so does their product;
• list_sum_mem, multiset_sum_mem, sum_mem: if each element of a collection belongs to an additive submonoid, then so does their sum;
• pow_mem, nsmul_mem: if x ∈ S where S is a multiplicative (resp., additive) submonoid and n is a natural number, then x^n (resp., n • x) belongs to S;
• mem_iSup_of_directed, coe_iSup_of_directed, mem_sSup_of_directedOn, coe_sSup_of_directedOn: the supremum of a directed collection of submonoid is their union.
• sup_eq_range, mem_sup: supremum of two submonoids S, T of a commutative monoid is the set of products;
• closure_singleton_eq, mem_closure_singleton, mem_closure_pair: the multiplicative (resp., additive) closure of {x} consists of powers (resp., natural multiples) of x, and a similar result holds for the closure of {x, y}.

Tags

submonoid, submonoids

@[simp]

theorem SubmonoidClass.coe_list_prod {M : Type u_1} {B : Type u_3} [Monoid M] [SetLike B M] [SubmonoidClass B M] {S : B} (l : List ↥S) : ↑l.prod = (List.map Subtype.val l).prod

@[simp]

theorem AddSubmonoidClass.coe_list_sum {M : Type u_1} {B : Type u_3} [AddMonoid M] [SetLike B M] [AddSubmonoidClass B M] {S : B} (l : List ↥S) : ↑l.sum = (List.map Subtype.val l).sum

@[simp]

theorem SubmonoidClass.coe_multiset_prod {B : Type u_3} {S : B} {M : Type u_4} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (m : Multiset ↥S) : ↑m.prod = (Multiset.map Subtype.val m).prod

@[simp]

theorem AddSubmonoidClass.coe_multiset_sum {B : Type u_3} {S : B} {M : Type u_4} [AddCommMonoid M] [SetLike B M] [AddSubmonoidClass B M] (m : Multiset ↥S) : ↑m.sum = (Multiset.map Subtype.val m).sum

@[simp]

theorem SubmonoidClass.coe_finset_prod {B : Type u_3} {S : B} {ι : Type u_4} {M : Type u_5} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → ↥S) (s : Finset ι) : ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)

@[simp]

theorem AddSubmonoidClass.coe_finset_sum {B : Type u_3} {S : B} {ι : Type u_4} {M : Type u_5} [AddCommMonoid M] [SetLike B M] [AddSubmonoidClass B M] (f : ι → ↥S) (s : Finset ι) : ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

theorem list_prod_mem {M : Type u_1} {B : Type u_3} [Monoid M] [SetLike B M] [SubmonoidClass B M] {S : B} {l : List M} (hl : ∀ x ∈ l, x ∈ S) : l.prod ∈ S

Product of a list of elements in a submonoid is in the submonoid.

theorem list_sum_mem {M : Type u_1} {B : Type u_3} [AddMonoid M] [SetLike B M] [AddSubmonoidClass B M] {S : B} {l : List M} (hl : ∀ x ∈ l, x ∈ S) : l.sum ∈ S

Sum of a list of elements in an AddSubmonoid is in the AddSubmonoid.

theorem multiset_prod_mem {B : Type u_3} {S : B} {M : Type u_4} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (m : Multiset M) (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S

Product of a multiset of elements in a submonoid of a CommMonoid is in the submonoid.

theorem multiset_sum_mem {B : Type u_3} {S : B} {M : Type u_4} [AddCommMonoid M] [SetLike B M] [AddSubmonoidClass B M] (m : Multiset M) (hm : ∀ a ∈ m, a ∈ S) : m.sum ∈ S

Sum of a multiset of elements in an AddSubmonoid of an AddCommMonoid is in the AddSubmonoid.

theorem prod_mem {B : Type u_3} {S : B} {M : Type u_4} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] {ι : Type u_5} {t : Finset ι} {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : ∏ c ∈ t, f c ∈ S

Product of elements of a submonoid of a CommMonoid indexed by a Finset is in the submonoid.

theorem sum_mem {B : Type u_3} {S : B} {M : Type u_4} [AddCommMonoid M] [SetLike B M] [AddSubmonoidClass B M] {ι : Type u_5} {t : Finset ι} {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : ∑ c ∈ t, f c ∈ S

Sum of elements in an AddSubmonoid of an AddCommMonoid indexed by a Finset is in the AddSubmonoid.

theorem Submonoid.coe_list_prod {M : Type u_1} [Monoid M] (s : Submonoid M) (l : List ↥s) : ↑l.prod = (List.map Subtype.val l).prod

theorem AddSubmonoid.coe_list_sum {M : Type u_1} [AddMonoid M] (s : AddSubmonoid M) (l : List ↥s) : ↑l.sum = (List.map Subtype.val l).sum

theorem Submonoid.coe_multiset_prod {M : Type u_4} [CommMonoid M] (S : Submonoid M) (m : Multiset ↥S) : ↑m.prod = (Multiset.map Subtype.val m).prod

theorem AddSubmonoid.coe_multiset_sum {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) (m : Multiset ↥S) : ↑m.sum = (Multiset.map Subtype.val m).sum

theorem Submonoid.coe_finset_prod {ι : Type u_4} {M : Type u_5} [CommMonoid M] (S : Submonoid M) (f : ι → ↥S) (s : Finset ι) : ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)

theorem AddSubmonoid.coe_finset_sum {ι : Type u_4} {M : Type u_5} [AddCommMonoid M] (S : AddSubmonoid M) (f : ι → ↥S) (s : Finset ι) : ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

theorem Submonoid.list_prod_mem {M : Type u_1} [Monoid M] (s : Submonoid M) {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.prod ∈ s

Product of a list of elements in a submonoid is in the submonoid.

theorem AddSubmonoid.list_sum_mem {M : Type u_1} [AddMonoid M] (s : AddSubmonoid M) {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.sum ∈ s

Sum of a list of elements in an AddSubmonoid is in the AddSubmonoid.

theorem Submonoid.multiset_prod_mem {M : Type u_4} [CommMonoid M] (S : Submonoid M) (m : Multiset M) (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S

Product of a multiset of elements in a submonoid of a CommMonoid is in the submonoid.

theorem AddSubmonoid.multiset_sum_mem {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) (m : Multiset M) (hm : ∀ a ∈ m, a ∈ S) : m.sum ∈ S

Sum of a multiset of elements in an AddSubmonoid of an AddCommMonoid is in the AddSubmonoid.

theorem Submonoid.multiset_noncommProd_mem {M : Type u_1} [Monoid M] (S : Submonoid M) (m : Multiset M) (comm : {x : M | x ∈ m}.Pairwise Commute) (h : ∀ x ∈ m, x ∈ S) : m.noncommProd comm ∈ S

theorem AddSubmonoid.multiset_noncommSum_mem {M : Type u_1} [AddMonoid M] (S : AddSubmonoid M) (m : Multiset M) (comm : {x : M | x ∈ m}.Pairwise AddCommute) (h : ∀ x ∈ m, x ∈ S) : m.noncommSum comm ∈ S

theorem Submonoid.prod_mem {M : Type u_4} [CommMonoid M] (S : Submonoid M) {ι : Type u_5} {t : Finset ι} {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : ∏ c ∈ t, f c ∈ S

Product of elements of a submonoid of a CommMonoid indexed by a Finset is in the submonoid.

theorem AddSubmonoid.sum_mem {M : Type u_4} [AddCommMonoid M] (S : AddSubmonoid M) {ι : Type u_5} {t : Finset ι} {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : ∑ c ∈ t, f c ∈ S

Sum of elements in an AddSubmonoid of an AddCommMonoid indexed by a Finset is in the AddSubmonoid.

theorem Submonoid.noncommProd_mem {M : Type u_1} [Monoid M] (S : Submonoid M) {ι : Type u_4} (t : Finset ι) (f : ι → M) (comm : (↑t).Pairwise fun (a b : ι) => Commute (f a) (f b)) (h : ∀ c ∈ t, f c ∈ S) : t.noncommProd f comm ∈ S

theorem AddSubmonoid.noncommSum_mem {M : Type u_1} [AddMonoid M] (S : AddSubmonoid M) {ι : Type u_4} (t : Finset ι) (f : ι → M) (comm : (↑t).Pairwise fun (a b : ι) => AddCommute (f a) (f b)) (h : ∀ c ∈ t, f c ∈ S) : t.noncommSum f comm ∈ S

theorem Submonoid.mem_iSup_of_directed {M : Type u_1} [MulOneClass M] {ι : Sort u_4} [hι : Nonempty ι] {S : ι → Submonoid M} (hS : Directed (fun (x1 x2 : Submonoid M) => x1 ≤ x2) S) {x : M} : x ∈ ⨆ (i : ι), S i ↔ ∃ (i : ι), x ∈ S i

theorem AddSubmonoid.mem_iSup_of_directed {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} [hι : Nonempty ι] {S : ι → AddSubmonoid M} (hS : Directed (fun (x1 x2 : AddSubmonoid M) => x1 ≤ x2) S) {x : M} : x ∈ ⨆ (i : ι), S i ↔ ∃ (i : ι), x ∈ S i

theorem Submonoid.coe_iSup_of_directed {M : Type u_1} [MulOneClass M] {ι : Sort u_4} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (fun (x1 x2 : Submonoid M) => x1 ≤ x2) S) : ↑(⨆ (i : ι), S i) = ⋃ (i : ι), ↑(S i)

theorem AddSubmonoid.coe_iSup_of_directed {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} [Nonempty ι] {S : ι → AddSubmonoid M} (hS : Directed (fun (x1 x2 : AddSubmonoid M) => x1 ≤ x2) S) : ↑(⨆ (i : ι), S i) = ⋃ (i : ι), ↑(S i)

theorem Submonoid.mem_sSup_of_directedOn {M : Type u_1} [MulOneClass M] {S : Set (Submonoid M)} (Sne : S.Nonempty) (hS : DirectedOn (fun (x1 x2 : Submonoid M) => x1 ≤ x2) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s

theorem AddSubmonoid.mem_sSup_of_directedOn {M : Type u_1} [AddZeroClass M] {S : Set (AddSubmonoid M)} (Sne : S.Nonempty) (hS : DirectedOn (fun (x1 x2 : AddSubmonoid M) => x1 ≤ x2) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s

theorem Submonoid.coe_sSup_of_directedOn {M : Type u_1} [MulOneClass M] {S : Set (Submonoid M)} (Sne : S.Nonempty) (hS : DirectedOn (fun (x1 x2 : Submonoid M) => x1 ≤ x2) S) : ↑(sSup S) = ⋃ s ∈ S, ↑s

theorem AddSubmonoid.coe_sSup_of_directedOn {M : Type u_1} [AddZeroClass M] {S : Set (AddSubmonoid M)} (Sne : S.Nonempty) (hS : DirectedOn (fun (x1 x2 : AddSubmonoid M) => x1 ≤ x2) S) : ↑(sSup S) = ⋃ s ∈ S, ↑s

theorem Submonoid.mem_sup_left {M : Type u_1} [MulOneClass M] {S T : Submonoid M} {x : M} : x ∈ S → x ∈ S ⊔ T

theorem AddSubmonoid.mem_sup_left {M : Type u_1} [AddZeroClass M] {S T : AddSubmonoid M} {x : M} : x ∈ S → x ∈ S ⊔ T

theorem Submonoid.mem_sup_right {M : Type u_1} [MulOneClass M] {S T : Submonoid M} {x : M} : x ∈ T → x ∈ S ⊔ T

theorem AddSubmonoid.mem_sup_right {M : Type u_1} [AddZeroClass M] {S T : AddSubmonoid M} {x : M} : x ∈ T → x ∈ S ⊔ T

theorem Submonoid.mul_mem_sup {M : Type u_1} [MulOneClass M] {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T

theorem AddSubmonoid.add_mem_sup {M : Type u_1} [AddZeroClass M] {S T : AddSubmonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T) : x + y ∈ S ⊔ T

theorem Submonoid.mem_iSup_of_mem {M : Type u_1} [MulOneClass M] {ι : Sort u_4} {S : ι → Submonoid M} (i : ι) {x : M} : x ∈ S i → x ∈ iSup S

theorem AddSubmonoid.mem_iSup_of_mem {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} {S : ι → AddSubmonoid M} (i : ι) {x : M} : x ∈ S i → x ∈ iSup S

theorem Submonoid.mem_sSup_of_mem {M : Type u_1} [MulOneClass M] {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) {x : M} : x ∈ s → x ∈ sSup S

theorem AddSubmonoid.mem_sSup_of_mem {M : Type u_1} [AddZeroClass M] {S : Set (AddSubmonoid M)} {s : AddSubmonoid M} (hs : s ∈ S) {x : M} : x ∈ s → x ∈ sSup S

theorem Submonoid.iSup_induction {M : Type u_1} [MulOneClass M] {ι : Sort u_4} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ (i : ι), S i) (mem : ∀ (i : ι), ∀ x ∈ S i, C x) (one : C 1) (mul : ∀ (x y : M), C x → C y → C (x * y)) : C x

An induction principle for elements of ⨆ i, S i. If C holds for 1 and all elements of S i for all i, and is preserved under multiplication, then it holds for all elements of the supremum of S.

theorem AddSubmonoid.iSup_induction {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} (S : ι → AddSubmonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ (i : ι), S i) (mem : ∀ (i : ι), ∀ x ∈ S i, C x) (one : C 0) (mul : ∀ (x y : M), C x → C y → C (x + y)) : C x

An induction principle for elements of ⨆ i, S i. If C holds for 0 and all elements of S i for all i, and is preserved under addition, then it holds for all elements of the supremum of S.

theorem Submonoid.iSup_induction' {M : Type u_1} [MulOneClass M] {ι : Sort u_4} (S : ι → Submonoid M) {C : (x : M) → x ∈ ⨆ (i : ι), S i → Prop} (mem : ∀ (i : ι) (x : M) (hxS : x ∈ S i), C x ⋯) (one : C 1 ⋯) (mul : ∀ (x y : M) (hx : x ∈ ⨆ (i : ι), S i) (hy : y ∈ ⨆ (i : ι), S i), C x hx → C y hy → C (x * y) ⋯) {x : M} (hx : x ∈ ⨆ (i : ι), S i) : C x hx

A dependent version of Submonoid.iSup_induction.

theorem AddSubmonoid.iSup_induction' {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} (S : ι → AddSubmonoid M) {C : (x : M) → x ∈ ⨆ (i : ι), S i → Prop} (mem : ∀ (i : ι) (x : M) (hxS : x ∈ S i), C x ⋯) (one : C 0 ⋯) (mul : ∀ (x y : M) (hx : x ∈ ⨆ (i : ι), S i) (hy : y ∈ ⨆ (i : ι), S i), C x hx → C y hy → C (x + y) ⋯) {x : M} (hx : x ∈ ⨆ (i : ι), S i) : C x hx

A dependent version of AddSubmonoid.iSup_induction.

theorem FreeMonoid.closure_range_of {α : Type u_4} : Submonoid.closure (Set.range FreeMonoid.of) = ⊤

theorem FreeAddMonoid.closure_range_of {α : Type u_4} : AddSubmonoid.closure (Set.range FreeAddMonoid.of) = ⊤

theorem Submonoid.closure_singleton_eq {M : Type u_1} [Monoid M] (x : M) : Submonoid.closure {x} = MonoidHom.mrange ((powersHom M) x)

theorem Submonoid.mem_closure_singleton {M : Type u_1} [Monoid M] {x y : M} : y ∈ Submonoid.closure {x} ↔ ∃ (n : ℕ), x ^ n = y

The submonoid generated by an element of a monoid equals the set of natural number powers of the element.

theorem Submonoid.mem_closure_singleton_self {M : Type u_1} [Monoid M] {y : M} : y ∈ Submonoid.closure {y}

theorem Submonoid.closure_singleton_one {M : Type u_1} [Monoid M] : Submonoid.closure {1} = ⊥

theorem Submonoid.card_bot {M : Type u_1} [Monoid M] {x✝ : Fintype ↥⊥} : Fintype.card ↥⊥ = 1

theorem AddSubmonoid.card_bot {M : Type u_1} [AddMonoid M] {x✝ : Fintype ↥⊥} : Fintype.card ↥⊥ = 1

theorem Submonoid.eq_bot_of_card_le {M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] (h : Fintype.card ↥S ≤ 1) : S = ⊥

theorem AddSubmonoid.eq_bot_of_card_le {M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] (h : Fintype.card ↥S ≤ 1) : S = ⊥

theorem Submonoid.eq_bot_of_card_eq {M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] (h : Fintype.card ↥S = 1) : S = ⊥

theorem AddSubmonoid.eq_bot_of_card_eq {M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] (h : Fintype.card ↥S = 1) : S = ⊥

theorem Submonoid.card_le_one_iff_eq_bot {M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] : Fintype.card ↥S ≤ 1 ↔ S = ⊥

theorem AddSubmonoid.card_le_one_iff_eq_bot {M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] : Fintype.card ↥S ≤ 1 ↔ S = ⊥

theorem Submonoid.eq_bot_iff_card {M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] : S = ⊥ ↔ Fintype.card ↥S = 1

theorem AddSubmonoid.eq_bot_iff_card {M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] : S = ⊥ ↔ Fintype.card ↥S = 1

theorem FreeMonoid.mrange_lift {M : Type u_1} [Monoid M] {α : Type u_4} (f : α → M) : MonoidHom.mrange (FreeMonoid.lift f) = Submonoid.closure (Set.range f)

theorem FreeAddMonoid.mrange_lift {M : Type u_1} [AddMonoid M] {α : Type u_4} (f : α → M) : AddMonoidHom.mrange (FreeAddMonoid.lift f) = AddSubmonoid.closure (Set.range f)

theorem Submonoid.closure_eq_mrange {M : Type u_1} [Monoid M] (s : Set M) : Submonoid.closure s = MonoidHom.mrange (FreeMonoid.lift Subtype.val)

theorem AddSubmonoid.closure_eq_mrange {M : Type u_1} [AddMonoid M] (s : Set M) : AddSubmonoid.closure s = AddMonoidHom.mrange (FreeAddMonoid.lift Subtype.val)

theorem Submonoid.closure_eq_image_prod {M : Type u_1} [Monoid M] (s : Set M) : ↑(Submonoid.closure s) = List.prod '' {l : List M | ∀ x ∈ l, x ∈ s}

theorem AddSubmonoid.closure_eq_image_sum {M : Type u_1} [AddMonoid M] (s : Set M) : ↑(AddSubmonoid.closure s) = List.sum '' {l : List M | ∀ x ∈ l, x ∈ s}

theorem Submonoid.exists_list_of_mem_closure {M : Type u_1} [Monoid M] {s : Set M} {x : M} (hx : x ∈ Submonoid.closure s) : ∃ (l : List M), (∀ y ∈ l, y ∈ s) ∧ l.prod = x

theorem AddSubmonoid.exists_list_of_mem_closure {M : Type u_1} [AddMonoid M] {s : Set M} {x : M} (hx : x ∈ AddSubmonoid.closure s) : ∃ (l : List M), (∀ y ∈ l, y ∈ s) ∧ l.sum = x

theorem Submonoid.exists_multiset_of_mem_closure {M : Type u_4} [CommMonoid M] {s : Set M} {x : M} (hx : x ∈ Submonoid.closure s) : ∃ (l : Multiset M), (∀ y ∈ l, y ∈ s) ∧ l.prod = x

theorem AddSubmonoid.exists_multiset_of_mem_closure {M : Type u_4} [AddCommMonoid M] {s : Set M} {x : M} (hx : x ∈ AddSubmonoid.closure s) : ∃ (l : Multiset M), (∀ y ∈ l, y ∈ s) ∧ l.sum = x

theorem Submonoid.closure_induction_left {M : Type u_1} [Monoid M] {s : Set M} {p : (m : M) → m ∈ Submonoid.closure s → Prop} (one : p 1 ⋯) (mul_left : ∀ (x : M) (hx : x ∈ s) (y : M) (hy : y ∈ Submonoid.closure s), p y hy → p (x * y) ⋯) {x : M} (h : x ∈ Submonoid.closure s) : p x h

theorem AddSubmonoid.closure_induction_left {M : Type u_1} [AddMonoid M] {s : Set M} {p : (m : M) → m ∈ AddSubmonoid.closure s → Prop} (one : p 0 ⋯) (mul_left : ∀ (x : M) (hx : x ∈ s) (y : M) (hy : y ∈ AddSubmonoid.closure s), p y hy → p (x + y) ⋯) {x : M} (h : x ∈ AddSubmonoid.closure s) : p x h

theorem Submonoid.induction_of_closure_eq_top_left {M : Type u_1} [Monoid M] {s : Set M} {p : M → Prop} (hs : Submonoid.closure s = ⊤) (x : M) (one : p 1) (mul : ∀ x ∈ s, ∀ (y : M), p y → p (x * y)) : p x

theorem AddSubmonoid.induction_of_closure_eq_top_left {M : Type u_1} [AddMonoid M] {s : Set M} {p : M → Prop} (hs : AddSubmonoid.closure s = ⊤) (x : M) (one : p 0) (mul : ∀ x ∈ s, ∀ (y : M), p y → p (x + y)) : p x

theorem Submonoid.closure_induction_right {M : Type u_1} [Monoid M] {s : Set M} {p : (m : M) → m ∈ Submonoid.closure s → Prop} (one : p 1 ⋯) (mul_right : ∀ (x : M) (hx : x ∈ Submonoid.closure s) (y : M) (hy : y ∈ s), p x hx → p (x * y) ⋯) {x : M} (h : x ∈ Submonoid.closure s) : p x h

theorem AddSubmonoid.closure_induction_right {M : Type u_1} [AddMonoid M] {s : Set M} {p : (m : M) → m ∈ AddSubmonoid.closure s → Prop} (one : p 0 ⋯) (mul_right : ∀ (x : M) (hx : x ∈ AddSubmonoid.closure s) (y : M) (hy : y ∈ s), p x hx → p (x + y) ⋯) {x : M} (h : x ∈ AddSubmonoid.closure s) : p x h

theorem Submonoid.induction_of_closure_eq_top_right {M : Type u_1} [Monoid M] {s : Set M} {p : M → Prop} (hs : Submonoid.closure s = ⊤) (x : M) (H1 : p 1) (Hmul : ∀ (x y : M), y ∈ s → p x → p (x * y)) : p x

theorem AddSubmonoid.induction_of_closure_eq_top_right {M : Type u_1} [AddMonoid M] {s : Set M} {p : M → Prop} (hs : AddSubmonoid.closure s = ⊤) (x : M) (H1 : p 0) (Hmul : ∀ (x y : M), y ∈ s → p x → p (x + y)) : p x

def Submonoid.powers {M : Type u_1} [Monoid M] (n : M) : Submonoid M

The submonoid generated by an element.

Equations

• Submonoid.powers n = (MonoidHom.mrange ((powersHom M) n)).copy (Set.range fun (x : ℕ) => n ^ x) ⋯

@[simp]

theorem Submonoid.mem_powers {M : Type u_1} [Monoid M] (n : M) : n ∈ Submonoid.powers n

theorem Submonoid.coe_powers {M : Type u_1} [Monoid M] (x : M) : ↑(Submonoid.powers x) = Set.range fun (n : ℕ) => x ^ n

theorem Submonoid.mem_powers_iff {M : Type u_1} [Monoid M] (x z : M) : x ∈ Submonoid.powers z ↔ ∃ (n : ℕ), z ^ n = x

noncomputable instance Submonoid.decidableMemPowers {M : Type u_1} [Monoid M] {a : M} : DecidablePred fun (x : M) => x ∈ Submonoid.powers a

Equations

• Submonoid.decidableMemPowers = Classical.decPred fun (x : M) => x ∈ Submonoid.powers a

noncomputable instance Submonoid.fintypePowers {M : Type u_1} [Monoid M] {a : M} [Fintype M] : Fintype ↥(Submonoid.powers a)

Equations

• Submonoid.fintypePowers = inferInstanceAs (Fintype ↥(Submonoid.powers a))

theorem Submonoid.powers_eq_closure {M : Type u_1} [Monoid M] (n : M) : Submonoid.powers n = Submonoid.closure {n}

theorem Submonoid.powers_le {M : Type u_1} [Monoid M] {n : M} {P : Submonoid M} : Submonoid.powers n ≤ P ↔ n ∈ P

@[simp]

theorem Submonoid.powers_one {M : Type u_1} [Monoid M] : Submonoid.powers 1 = ⊥

@[reducible, inline]

abbrev Submonoid.groupPowers {M : Type u_1} [Monoid M] {x : M} {n : ℕ} (hpos : 0 < n) (hx : x ^ n = 1) : Group ↥(Submonoid.powers x)

The submonoid generated by an element is a group if that element has finite order.

Equations

• Submonoid.groupPowers hpos hx = Group.mk ⋯

def Submonoid.pow {M : Type u_1} [Monoid M] (n : M) (m : ℕ) : ↥(Submonoid.powers n)

Exponentiation map from natural numbers to powers.

Equations

• Submonoid.pow n m = ((powersHom M) n).mrangeRestrict (Multiplicative.ofAdd m)

@[simp]

theorem Submonoid.pow_coe {M : Type u_1} [Monoid M] (n : M) (m : ℕ) : ↑(Submonoid.pow n m) = n ^ m

theorem Submonoid.pow_apply {M : Type u_1} [Monoid M] (n : M) (m : ℕ) : Submonoid.pow n m = ⟨n ^ m, ⋯⟩

def Submonoid.log {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (p : ↥(Submonoid.powers n)) : ℕ

Logarithms from powers to natural numbers.

Equations

• Submonoid.log p = Nat.find ⋯

@[simp]

theorem Submonoid.pow_log_eq_self {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (p : ↥(Submonoid.powers n)) : Submonoid.pow n (Submonoid.log p) = p

theorem Submonoid.pow_right_injective_iff_pow_injective {M : Type u_1} [Monoid M] {n : M} : (Function.Injective fun (m : ℕ) => n ^ m) ↔ Function.Injective (Submonoid.pow n)

@[simp]

theorem Submonoid.log_pow_eq_self {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun (m : ℕ) => n ^ m) (m : ℕ) : Submonoid.log (Submonoid.pow n m) = m

def Submonoid.powLogEquiv {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun (m : ℕ) => n ^ m) : Multiplicative ℕ ≃* ↥(Submonoid.powers n)

The exponentiation map is an isomorphism from the additive monoid on natural numbers to powers when it is injective. The inverse is given by the logarithms.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Submonoid.powLogEquiv_apply {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun (m : ℕ) => n ^ m) (m : Multiplicative ℕ) : (Submonoid.powLogEquiv h) m = Submonoid.pow n (Multiplicative.toAdd m)

@[simp]

theorem Submonoid.powLogEquiv_symm_apply {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun (m : ℕ) => n ^ m) (m : ↥(Submonoid.powers n)) : (Submonoid.powLogEquiv h).symm m = Multiplicative.ofAdd (Submonoid.log m)

theorem Submonoid.log_mul {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun (m : ℕ) => n ^ m) (x y : ↥(Submonoid.powers n)) : Submonoid.log (x * y) = Submonoid.log x + Submonoid.log y

theorem Submonoid.log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : Submonoid.log (Submonoid.pow x m) = m

@[simp]

theorem Submonoid.map_powers {M : Type u_1} [Monoid M] {N : Type u_4} {F : Type u_5} [Monoid N] [FunLike F M N] [MonoidHomClass F M N] (f : F) (m : M) : Submonoid.map f (Submonoid.powers m) = Submonoid.powers (f m)

def Submonoid.closureCommMonoidOfComm {M : Type u_1} [Monoid M] {s : Set M} (hcomm : ∀ a ∈ s, ∀ b ∈ s, a * b = b * a) : CommMonoid ↥(Submonoid.closure s)

If all the elements of a set s commute, then closure s is a commutative monoid.

Equations

• Submonoid.closureCommMonoidOfComm hcomm = CommMonoid.mk ⋯

def AddSubmonoid.closureAddCommMonoidOfComm {M : Type u_1} [AddMonoid M] {s : Set M} (hcomm : ∀ a ∈ s, ∀ b ∈ s, a + b = b + a) : AddCommMonoid ↥(AddSubmonoid.closure s)

If all the elements of a set s commute, then closure s forms an additive commutative monoid.

Equations

• AddSubmonoid.closureAddCommMonoidOfComm hcomm = AddCommMonoid.mk ⋯

theorem IsScalarTower.of_mclosure_eq_top {M : Type u_1} {N : Type u_4} {α : Type u_5} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α] {s : Set M} (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z) : IsScalarTower M N α

theorem VAddAssocClass.of_mclosure_eq_top {M : Type u_1} {N : Type u_4} {α : Type u_5} [AddMonoid M] [AddAction M N] [VAdd N α] [AddAction M α] {s : Set M} (htop : AddSubmonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x +ᵥ y +ᵥ z = x +ᵥ (y +ᵥ z)) : VAddAssocClass M N α

theorem SMulCommClass.of_mclosure_eq_top {M : Type u_1} {N : Type u_4} {α : Type u_5} [Monoid M] [SMul N α] [MulAction M α] {s : Set M} (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x • y • z = y • x • z) : SMulCommClass M N α

theorem VAddCommClass.of_mclosure_eq_top {M : Type u_1} {N : Type u_4} {α : Type u_5} [AddMonoid M] [VAdd N α] [AddAction M α] {s : Set M} (htop : AddSubmonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x +ᵥ (y +ᵥ z) = y +ᵥ (x +ᵥ z)) : VAddCommClass M N α

theorem Submonoid.sup_eq_range {N : Type u_4} [CommMonoid N] (s t : Submonoid N) : s ⊔ t = MonoidHom.mrange (s.subtype.coprod t.subtype)

theorem AddSubmonoid.sup_eq_range {N : Type u_4} [AddCommMonoid N] (s t : AddSubmonoid N) : s ⊔ t = AddMonoidHom.mrange (s.subtype.coprod t.subtype)

theorem Submonoid.mem_sup {N : Type u_4} [CommMonoid N] {s t : Submonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x

theorem AddSubmonoid.mem_sup {N : Type u_4} [AddCommMonoid N] {s t : AddSubmonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y + z = x

theorem AddSubmonoid.closure_singleton_eq {A : Type u_2} [AddMonoid A] (x : A) : AddSubmonoid.closure {x} = AddMonoidHom.mrange ((multiplesHom A) x)

theorem AddSubmonoid.mem_closure_singleton {A : Type u_2} [AddMonoid A] {x y : A} : y ∈ AddSubmonoid.closure {x} ↔ ∃ (n : ℕ), n • x = y

The AddSubmonoid generated by an element of an AddMonoid equals the set of natural number multiples of the element.

theorem AddSubmonoid.closure_singleton_zero {A : Type u_2} [AddMonoid A] : AddSubmonoid.closure {0} = ⊥

def AddSubmonoid.multiples {A : Type u_2} [AddMonoid A] (x : A) : AddSubmonoid A

The additive submonoid generated by an element.

Equations

• AddSubmonoid.multiples x = (AddMonoidHom.mrange ((multiplesHom A) x)).copy (Set.range fun (i : ℕ) => i • x) ⋯

@[simp]

theorem AddSubmonoid.mem_multiples {M : Type u_1} [AddMonoid M] (n : M) : n ∈ AddSubmonoid.multiples n

theorem AddSubmonoid.coe_multiples {M : Type u_1} [AddMonoid M] (x : M) : ↑(AddSubmonoid.multiples x) = Set.range fun (n : ℕ) => n • x

theorem AddSubmonoid.mem_multiples_iff {M : Type u_1} [AddMonoid M] (x z : M) : x ∈ AddSubmonoid.multiples z ↔ ∃ (n : ℕ), n • z = x

noncomputable instance AddSubmonoid.decidableMemMultiples {M : Type u_1} [AddMonoid M] {a : M} : DecidablePred fun (x : M) => x ∈ AddSubmonoid.multiples a

Equations

• AddSubmonoid.decidableMemMultiples = Classical.decPred fun (x : M) => x ∈ AddSubmonoid.multiples a

noncomputable instance AddSubmonoid.fintypeMultiples {M : Type u_1} [AddMonoid M] {a : M} [Fintype M] : Fintype ↥(AddSubmonoid.multiples a)

Equations

• AddSubmonoid.fintypeMultiples = inferInstanceAs (Fintype ↥(AddSubmonoid.multiples a))

theorem AddSubmonoid.multiples_eq_closure {M : Type u_1} [AddMonoid M] (n : M) : AddSubmonoid.multiples n = AddSubmonoid.closure {n}

theorem AddSubmonoid.multiples_le {M : Type u_1} [AddMonoid M] {n : M} {P : AddSubmonoid M} : AddSubmonoid.multiples n ≤ P ↔ n ∈ P

@[simp]

theorem AddSubmonoid.multiples_zero {M : Type u_1} [AddMonoid M] : AddSubmonoid.multiples 0 = ⊥

@[reducible, inline]

abbrev AddSubmonoid.addGroupMultiples {M : Type u_1} [AddMonoid M] {x : M} {n : ℕ} (hpos : 0 < n) (hx : n • x = 0) : AddGroup ↥(AddSubmonoid.multiples x)

The additive submonoid generated by an element is an additive group if that element has finite order.

Equations

• AddSubmonoid.addGroupMultiples hpos hx = AddGroup.mk ⋯

Lemmas about additive closures of Subsemigroup.

theorem MulMemClass.mul_right_mem_add_closure {M : Type u_1} {R : Type u_4} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M} {a b : R} (ha : a ∈ AddSubmonoid.closure ↑S) (hb : b ∈ S) : a * b ∈ AddSubmonoid.closure ↑S

The product of an element of the additive closure of a multiplicative subsemigroup M and an element of M is contained in the additive closure of M.

theorem MulMemClass.mul_mem_add_closure {M : Type u_1} {R : Type u_4} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M} {a b : R} (ha : a ∈ AddSubmonoid.closure ↑S) (hb : b ∈ AddSubmonoid.closure ↑S) : a * b ∈ AddSubmonoid.closure ↑S

The product of two elements of the additive closure of a submonoid M is an element of the additive closure of M.

theorem MulMemClass.mul_left_mem_add_closure {M : Type u_1} {R : Type u_4} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M} {a b : R} (ha : a ∈ S) (hb : b ∈ AddSubmonoid.closure ↑S) : a * b ∈ AddSubmonoid.closure ↑S

The product of an element of S and an element of the additive closure of a multiplicative submonoid S is contained in the additive closure of S.

theorem Submonoid.mem_closure_pair {A : Type u_4} [CommMonoid A] (a b c : A) : c ∈ Submonoid.closure {a, b} ↔ ∃ (m : ℕ) (n : ℕ), a ^ m * b ^ n = c

An element is in the closure of a two-element set if it is a linear combination of those two elements.

theorem AddSubmonoid.mem_closure_pair {A : Type u_4} [AddCommMonoid A] (a b c : A) : c ∈ AddSubmonoid.closure {a, b} ↔ ∃ (m : ℕ) (n : ℕ), m • a + n • b = c

An element is in the closure of a two-element set if it is a linear combination of those two elements.

theorem ofMul_image_powers_eq_multiples_ofMul {M : Type u_1} [Monoid M] {x : M} : ⇑Additive.ofMul '' ↑(Submonoid.powers x) = ↑(AddSubmonoid.multiples (Additive.ofMul x))

theorem ofAdd_image_multiples_eq_powers_ofAdd {A : Type u_2} [AddMonoid A] {x : A} : ⇑Multiplicative.ofAdd '' ↑(AddSubmonoid.multiples x) = ↑(Submonoid.powers (Multiplicative.ofAdd x))

def Submonoid.isPrimal (α : Type u_4) [CancelCommMonoidWithZero α] : Submonoid α

The submonoid of primal elements in a cancellative commutative monoid with zero.

Equations

• Submonoid.isPrimal α = { carrier := {a : α | IsPrimal a}, mul_mem' := ⋯, one_mem' := ⋯ }