fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
doubleCoset_union_rightCoset (H K : Subgroup G) (a : G) :
⋃ k : K, op (a * k) • ↑H = doubleCoset a H K := by
ext x
simp only [mem_rightCoset_iff, mul_inv_rev, Set.mem_iUnion, mem_doubleCoset,
SetLike.mem_coe]
constructor
· rintro ⟨y, h_h⟩
refine ⟨x * (y⁻¹ * a⁻¹), h_h, y, y.2, ?_⟩
simp only [← mul_assoc, inv_mul_cancel_right, InvMemClass.coe_inv]
· rintro ⟨x, hx, y, hy, hxy⟩
refine ⟨⟨y, hy⟩, ?_⟩
simp only [hxy, ← mul_assoc, hx, mul_inv_cancel_right]
@[deprecated (since := "2025-07-12")]
alias _root_.Doset.doset_union_rightCoset := doubleCoset_union_rightCoset | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | doubleCoset_union_rightCoset | null |
doubleCoset_union_leftCoset (H K : Subgroup G) (a : G) :
⋃ h : H, (h * a : G) • ↑K = doubleCoset a H K := by
ext x
simp only [mem_leftCoset_iff, mul_inv_rev, Set.mem_iUnion, mem_doubleCoset]
constructor
· rintro ⟨y, h_h⟩
refine ⟨y, y.2, a⁻¹ * y⁻¹ * x, h_h, ?_⟩
simp only [← mul_assoc, one_mul, mul_inv_cancel, mul_inv_cancel_right, InvMemClass.coe_inv]
· rintro ⟨x, hx, y, hy, hxy⟩
refine ⟨⟨x, hx⟩, ?_⟩
simp only [hxy, ← mul_assoc, hy, one_mul, inv_mul_cancel, inv_mul_cancel_right]
@[deprecated (since := "2025-07-12")]
alias _root_.Doset.doset_union_leftCoset := doubleCoset_union_leftCoset | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | doubleCoset_union_leftCoset | null |
left_bot_eq_left_quot (H : Subgroup G) :
Quotient (⊥ : Subgroup G) (H : Set G) = (G ⧸ H) := by
unfold Quotient
congr
ext
simp_rw [← bot_rel_eq_leftRel H]
@[deprecated (since := "2025-07-12")]
alias _root_.Doset.left_bot_eq_left_quot := left_bot_eq_left_quot | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | left_bot_eq_left_quot | null |
right_bot_eq_right_quot (H : Subgroup G) :
Quotient (H : Set G) (⊥ : Subgroup G) = _root_.Quotient (QuotientGroup.rightRel H) := by
unfold Quotient
congr
ext
simp_rw [← rel_bot_eq_right_group_rel H]
@[deprecated (since := "2025-07-12")]
alias _root_.Doset.right_bot_eq_right_quot := right_bot_eq_right_quot | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | right_bot_eq_right_quot | null |
IsUnital (m : X → X → X) (e : X) : Prop extends Std.LawfulIdentity m e
@[to_additive EckmannHilton.AddZeroClass.IsUnital] | structure | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | IsUnital | Local notation for `m a b`. -/
local notation a " <" m:51 "> " b => m a b
/-- `IsUnital m e` expresses that `e : X` is a left and right unit
for the binary operation `m : X → X → X`. |
MulOneClass.isUnital [_G : MulOneClass X] : IsUnital (· * ·) (1 : X) :=
IsUnital.mk { left_id := MulOneClass.one_mul,
right_id := MulOneClass.mul_one }
variable {m₁ m₂ : X → X → X} {e₁ e₂ : X}
variable (h₁ : IsUnital m₁ e₁) (h₂ : IsUnital m₂ e₂)
variable (distrib : ∀ a b c d, ((a <m₂> b) <m₁> c <m₂> d) = (a <m₁> c) <m₂> b <m₁> d)
include h₁ h₂ distrib | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | MulOneClass.isUnital | null |
one : e₁ = e₂ := by
simpa only [h₁.left_id, h₁.right_id, h₂.left_id, h₂.right_id] using distrib e₂ e₁ e₁ e₂ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | one | If a type carries two unital binary operations that distribute over each other,
then they have the same unit elements.
In fact, the two operations are the same, and give a commutative monoid structure,
see `eckmann_hilton.CommMonoid`. |
mul : m₁ = m₂ := by
funext a b
calc
m₁ a b = m₁ (m₂ a e₁) (m₂ e₁ b) := by
{ simp only [one h₁ h₂ distrib, h₂.left_id, h₂.right_id] }
_ = m₂ a b := by simp only [distrib, h₁.left_id, h₁.right_id] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | mul | If a type carries two unital binary operations that distribute over each other,
then these operations are equal.
In fact, they give a commutative monoid structure, see `eckmann_hilton.CommMonoid`. |
mul_comm : Std.Commutative m₂ :=
⟨fun a b => by simpa [mul h₁ h₂ distrib, h₂.left_id, h₂.right_id] using distrib e₂ a b e₂⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | mul_comm | If a type carries two unital binary operations that distribute over each other,
then these operations are commutative.
In fact, they give a commutative monoid structure, see `eckmann_hilton.CommMonoid`. |
mul_assoc : Std.Associative m₂ :=
⟨fun a b c => by simpa [mul h₁ h₂ distrib, h₂.left_id, h₂.right_id] using distrib a b e₂ c⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | mul_assoc | If a type carries two unital binary operations that distribute over each other,
then these operations are associative.
In fact, they give a commutative monoid structure, see `eckmann_hilton.CommMonoid`. |
@[to_additive
/-- If a type carries a unital additive magma structure that distributes over a unital binary
operation, then the additive magma structure is a commutative additive monoid. -/]
commMonoid [h : MulOneClass X]
(distrib : ∀ a b c d, ((a * b) <m₁> c * d) = (a <m₁> c) * b <m₁> d) : CommMonoid X :=
{ h with
mul_comm := (mul_comm h₁ MulOneClass.isUnital distrib).comm,
mul_assoc := (mul_assoc h₁ MulOneClass.isUnital distrib).assoc } | abbrev | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | commMonoid | If a type carries a unital magma structure that distributes over a unital binary
operation, then the magma structure is a commutative monoid. |
@[to_additive
/-- If a type carries an additive group structure that distributes over a unital binary
operation, then the additive group is commutative. -/]
commGroup [G : Group X]
(distrib : ∀ a b c d, ((a * b) <m₁> c * d) = (a <m₁> c) * b <m₁> d) : CommGroup X :=
{ EckmannHilton.commMonoid h₁ distrib, G with .. } | abbrev | GroupTheory | [
"Mathlib.Algebra.Group.Defs"
] | Mathlib/GroupTheory/EckmannHilton.lean | commGroup | If a type carries a group structure that distributes over a unital binary operation,
then the group is commutative. |
@[to_additive
/-- A predicate on an additive monoid saying that there is a positive integer `n` such that
`n • g = 0` for all `g`. -/]
ExponentExists :=
∃ n, 0 < n ∧ ∀ g : G, g ^ n = 1
open scoped Classical in | def | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | ExponentExists | A predicate on a monoid saying that there is a positive integer `n` such that `g ^ n = 1`
for all `g`. |
@[to_additive
/-- The exponent of an additive group is the smallest positive integer `n` such that
`n • g = 0` for all `g ∈ G` if it exists, otherwise it is zero by convention. -/]
noncomputable exponent :=
if h : ExponentExists G then Nat.find h else 0
variable {G}
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent | The exponent of a group is the smallest positive integer `n` such that `g ^ n = 1` for all
`g ∈ G` if it exists, otherwise it is zero by convention. |
_root_.AddMonoid.exponent_additive :
AddMonoid.exponent (Additive G) = exponent G := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | _root_.AddMonoid.exponent_additive | null |
exponent_multiplicative {G : Type*} [AddMonoid G] :
exponent (Multiplicative G) = AddMonoid.exponent G := rfl
open MulOpposite in
@[to_additive (attr := simp)] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_multiplicative | null |
_root_.MulOpposite.exponent : exponent (MulOpposite G) = exponent G := by
simp only [Monoid.exponent, ExponentExists]
congr!
all_goals exact ⟨(op_injective <| · <| op ·), (unop_injective <| · <| unop ·)⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | _root_.MulOpposite.exponent | null |
ExponentExists.isOfFinOrder (h : ExponentExists G) {g : G} : IsOfFinOrder g :=
isOfFinOrder_iff_pow_eq_one.mpr <| by peel 2 h; exact this g
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | ExponentExists.isOfFinOrder | null |
ExponentExists.orderOf_pos (h : ExponentExists G) (g : G) : 0 < orderOf g :=
h.isOfFinOrder.orderOf_pos
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | ExponentExists.orderOf_pos | null |
exponent_ne_zero : exponent G ≠ 0 ↔ ExponentExists G := by
rw [exponent]
split_ifs with h
· simp [h]
· tauto
@[to_additive]
protected alias ⟨_, ExponentExists.exponent_ne_zero⟩ := exponent_ne_zero
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_ne_zero | null |
exponent_pos : 0 < exponent G ↔ ExponentExists G :=
pos_iff_ne_zero.trans exponent_ne_zero
@[to_additive]
protected alias ⟨_, ExponentExists.exponent_pos⟩ := exponent_pos
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_pos | null |
exponent_eq_zero_iff : exponent G = 0 ↔ ¬ExponentExists G :=
exponent_ne_zero.not_right
@[to_additive exponent_eq_zero_addOrder_zero] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_zero_iff | null |
exponent_eq_zero_of_order_zero {g : G} (hg : orderOf g = 0) : exponent G = 0 :=
exponent_eq_zero_iff.mpr fun h ↦ h.orderOf_pos g |>.ne' hg
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_zero_of_order_zero | null |
exponent_eq_sInf :
Monoid.exponent G = sInf {d : ℕ | 0 < d ∧ ∀ x : G, x ^ d = 1} := by
by_cases h : Monoid.ExponentExists G
· have h' : {d : ℕ | 0 < d ∧ ∀ x : G, x ^ d = 1}.Nonempty := h
rw [Monoid.exponent, dif_pos h, Nat.sInf_def h']
congr
· have : {d | 0 < d ∧ ∀ (x : G), x ^ d = 1} = ∅ :=
Set.eq_empty_of_forall_notMem fun n hn ↦ h ⟨n, hn⟩
rw [Monoid.exponent_eq_zero_iff.mpr h, this, Nat.sInf_empty] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_sInf | null |
@[to_additive /-- The exponent is zero iff for all nonzero `n`, one can find a `g` such that
`n • g ≠ 0`. -/]
exponent_eq_zero_iff_forall : exponent G = 0 ↔ ∀ n > 0, ∃ g : G, g ^ n ≠ 1 := by
rw [exponent_eq_zero_iff, ExponentExists]
push_neg
rfl
@[to_additive exponent_nsmul_eq_zero] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_zero_iff_forall | The exponent is zero iff for all nonzero `n`, one can find a `g` such that `g ^ n ≠ 1`. |
pow_exponent_eq_one (g : G) : g ^ exponent G = 1 := by
classical
by_cases h : ExponentExists G
· simp_rw [exponent, dif_pos h]
exact (Nat.find_spec h).2 g
· simp_rw [exponent, dif_neg h, pow_zero]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | pow_exponent_eq_one | null |
pow_eq_mod_exponent {n : ℕ} (g : G) : g ^ n = g ^ (n % exponent G) :=
calc
g ^ n = g ^ (n % exponent G + exponent G * (n / exponent G)) := by rw [Nat.mod_add_div]
_ = g ^ (n % exponent G) := by simp [pow_add, pow_mul, pow_exponent_eq_one]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | pow_eq_mod_exponent | null |
exponent_pos_of_exists (n : ℕ) (hpos : 0 < n) (hG : ∀ g : G, g ^ n = 1) :
0 < exponent G :=
ExponentExists.exponent_pos ⟨n, hpos, hG⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_pos_of_exists | null |
exponent_min' (n : ℕ) (hpos : 0 < n) (hG : ∀ g : G, g ^ n = 1) : exponent G ≤ n := by
classical
rw [exponent, dif_pos]
· apply Nat.find_min'
exact ⟨hpos, hG⟩
· exact ⟨n, hpos, hG⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_min' | null |
exponent_min (m : ℕ) (hpos : 0 < m) (hm : m < exponent G) : ∃ g : G, g ^ m ≠ 1 := by
by_contra! h
have hcon : exponent G ≤ m := exponent_min' m hpos h
cutsat
@[to_additive AddMonoid.exp_eq_one_iff] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_min | null |
exp_eq_one_iff : exponent G = 1 ↔ Subsingleton G := by
refine ⟨fun eq_one => ⟨fun a b => ?a_eq_b⟩, fun h => le_antisymm ?le ?ge⟩
· rw [← pow_one a, ← pow_one b, ← eq_one, Monoid.pow_exponent_eq_one, Monoid.pow_exponent_eq_one]
· apply exponent_min' _ Nat.one_pos
simp [eq_iff_true_of_subsingleton]
· apply Nat.succ_le_of_lt
apply exponent_pos_of_exists 1 Nat.one_pos
simp [eq_iff_true_of_subsingleton]
@[to_additive (attr := simp) AddMonoid.exp_eq_one_of_subsingleton] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exp_eq_one_iff | null |
exp_eq_one_of_subsingleton [hs : Subsingleton G] : exponent G = 1 :=
exp_eq_one_iff.mpr hs
@[to_additive addOrder_dvd_exponent] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exp_eq_one_of_subsingleton | null |
order_dvd_exponent (g : G) : orderOf g ∣ exponent G :=
orderOf_dvd_of_pow_eq_one <| pow_exponent_eq_one g
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | order_dvd_exponent | null |
orderOf_le_exponent (h : ExponentExists G) (g : G) : orderOf g ≤ exponent G :=
Nat.le_of_dvd h.exponent_pos (order_dvd_exponent g)
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | orderOf_le_exponent | null |
exponent_dvd_iff_forall_pow_eq_one {n : ℕ} : exponent G ∣ n ↔ ∀ g : G, g ^ n = 1 := by
rcases n.eq_zero_or_pos with (rfl | hpos)
· simp
constructor
· intro h g
rw [Nat.dvd_iff_mod_eq_zero] at h
rw [pow_eq_mod_exponent, h, pow_zero]
· intro hG
by_contra h
rw [Nat.dvd_iff_mod_eq_zero, ← Ne, ← pos_iff_ne_zero] at h
have h₂ : n % exponent G < exponent G := Nat.mod_lt _ (exponent_pos_of_exists n hpos hG)
have h₃ : exponent G ≤ n % exponent G := by
apply exponent_min' _ h
simp_rw [← pow_eq_mod_exponent]
exact hG
exact h₂.not_ge h₃
@[to_additive]
alias ⟨_, exponent_dvd_of_forall_pow_eq_one⟩ := exponent_dvd_iff_forall_pow_eq_one
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_dvd_iff_forall_pow_eq_one | null |
exponent_dvd {n : ℕ} : exponent G ∣ n ↔ ∀ g : G, orderOf g ∣ n := by
simp_rw [exponent_dvd_iff_forall_pow_eq_one, orderOf_dvd_iff_pow_eq_one]
variable (G)
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_dvd | null |
lcm_orderOf_dvd_exponent [Fintype G] :
(Finset.univ : Finset G).lcm orderOf ∣ exponent G := by
apply Finset.lcm_dvd
intro g _
exact order_dvd_exponent g
@[to_additive exists_addOrderOf_eq_pow_padic_val_nat_add_exponent] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | lcm_orderOf_dvd_exponent | null |
_root_.Nat.Prime.exists_orderOf_eq_pow_factorization_exponent {p : ℕ} (hp : p.Prime) :
∃ g : G, orderOf g = p ^ (exponent G).factorization p := by
haveI := Fact.mk hp
rcases eq_or_ne ((exponent G).factorization p) 0 with (h | h)
· refine ⟨1, by rw [h, pow_zero, orderOf_one]⟩
have he : 0 < exponent G :=
Ne.bot_lt fun ht => by
rw [ht] at h
apply h
rw [bot_eq_zero, Nat.factorization_zero, Finsupp.zero_apply]
rw [← Finsupp.mem_support_iff] at h
obtain ⟨g, hg⟩ : ∃ g : G, g ^ (exponent G / p) ≠ 1 := by
suffices key : ¬exponent G ∣ exponent G / p by
rwa [exponent_dvd_iff_forall_pow_eq_one, not_forall] at key
exact fun hd =>
hp.one_lt.not_ge
((mul_le_iff_le_one_left he).mp <|
Nat.le_of_dvd he <| Nat.mul_dvd_of_dvd_div (Nat.dvd_of_mem_primeFactors h) hd)
obtain ⟨k, hk : exponent G = p ^ _ * k⟩ := Nat.ordProj_dvd _ _
obtain ⟨t, ht⟩ := Nat.exists_eq_succ_of_ne_zero (Finsupp.mem_support_iff.mp h)
refine ⟨g ^ k, ?_⟩
rw [ht]
apply orderOf_eq_prime_pow
· rwa [hk, mul_comm, ht, pow_succ, ← mul_assoc, Nat.mul_div_cancel _ hp.pos, pow_mul] at hg
· rw [← Nat.succ_eq_add_one, ← ht, ← pow_mul, mul_comm, ← hk]
exact pow_exponent_eq_one g
variable {G} in
open Nat in | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | _root_.Nat.Prime.exists_orderOf_eq_pow_factorization_exponent | null |
@[to_additive /-- If two commuting elements `x` and `y` of an additive monoid have order `n` and
`m`, there is an element of order `lcm n m`. The result actually gives an explicit (computable)
element, written as the sum of a multiple of `x` and a multiple of `y`. See also the result below
if you don't need the explicit formula. -/]
_root_.Commute.orderOf_mul_pow_eq_lcm {x y : G} (h : Commute x y) (hx : orderOf x ≠ 0)
(hy : orderOf y ≠ 0) :
orderOf (x ^ (orderOf x / (factorizationLCMLeft (orderOf x) (orderOf y))) *
y ^ (orderOf y / factorizationLCMRight (orderOf x) (orderOf y))) =
Nat.lcm (orderOf x) (orderOf y) := by
rw [(h.pow_pow _ _).orderOf_mul_eq_mul_orderOf_of_coprime]
all_goals iterate 2 rw [orderOf_pow_orderOf_div]; try rw [Coprime]
all_goals simp [factorizationLCMLeft_mul_factorizationLCMRight, factorizationLCMLeft_dvd_left,
factorizationLCMRight_dvd_right, coprime_factorizationLCMLeft_factorizationLCMRight, hx, hy]
open Submonoid in | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | _root_.Commute.orderOf_mul_pow_eq_lcm | If two commuting elements `x` and `y` of a monoid have order `n` and `m`, there is an element
of order `lcm n m`. The result actually gives an explicit (computable) element, written as the
product of a power of `x` and a power of `y`. See also the result below if you don't need the
explicit formula. |
@[to_additive /-- If two commuting elements `x` and `y` of an additive monoid have order `n` and
`m`, then there is an element of order `lcm n m` that lies in the additive subgroup generated by `x`
and `y`. -/]
_root_.Commute.exists_orderOf_eq_lcm {x y : G} (h : Commute x y) :
∃ z ∈ closure {x, y}, orderOf z = Nat.lcm (orderOf x) (orderOf y) := by
by_cases hx : orderOf x = 0 <;> by_cases hy : orderOf y = 0
· exact ⟨x, subset_closure (by simp), by simp [hx]⟩
· exact ⟨x, subset_closure (by simp), by simp [hx]⟩
· exact ⟨y, subset_closure (by simp), by simp [hy]⟩
· exact ⟨_, mul_mem (pow_mem (subset_closure (by simp)) _) (pow_mem (subset_closure (by simp)) _),
h.orderOf_mul_pow_eq_lcm hx hy⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | _root_.Commute.exists_orderOf_eq_lcm | If two commuting elements `x` and `y` of a monoid have order `n` and `m`, then there is an
element of order `lcm n m` that lies in the subgroup generated by `x` and `y`. |
@[to_additive]
exponent_eq_prime_iff {G : Type*} [Monoid G] [Nontrivial G] {p : ℕ} (hp : p.Prime) :
Monoid.exponent G = p ↔ ∀ g : G, g ≠ 1 → orderOf g = p := by
refine ⟨fun hG g hg ↦ ?_, fun h ↦ dvd_antisymm ?_ ?_⟩
· rw [Ne, ← orderOf_eq_one_iff] at hg
exact Eq.symm <| (hp.dvd_iff_eq hg).mp <| hG ▸ Monoid.order_dvd_exponent g
· rw [exponent_dvd]
intro g
by_cases hg : g = 1
· simp [hg]
· rw [h g hg]
· obtain ⟨g, hg⟩ := exists_ne (1 : G)
simpa [h g hg] using Monoid.order_dvd_exponent g
variable {G}
@[to_additive] | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_prime_iff | A nontrivial monoid has prime exponent `p` if and only if every non-identity element has
order `p`. |
exponent_ne_zero_iff_range_orderOf_finite (h : ∀ g : G, 0 < orderOf g) :
exponent G ≠ 0 ↔ (Set.range (orderOf : G → ℕ)).Finite := by
refine ⟨fun he => ?_, fun he => ?_⟩
· by_contra h
obtain ⟨m, ⟨t, rfl⟩, het⟩ := Set.Infinite.exists_gt h (exponent G)
exact pow_ne_one_of_lt_orderOf he het (pow_exponent_eq_one t)
· lift Set.range (orderOf (G := G)) to Finset ℕ using he with t ht
have htpos : 0 < t.prod id := by
refine Finset.prod_pos fun a ha => ?_
rw [← Finset.mem_coe, ht] at ha
obtain ⟨k, rfl⟩ := ha
exact h k
suffices exponent G ∣ t.prod id by
intro h
rw [h, zero_dvd_iff] at this
exact htpos.ne' this
rw [exponent_dvd]
intro g
apply Finset.dvd_prod_of_mem id (?_ : orderOf g ∈ _)
rw [← Finset.mem_coe, ht]
exact Set.mem_range_self g
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_ne_zero_iff_range_orderOf_finite | null |
exponent_eq_zero_iff_range_orderOf_infinite (h : ∀ g : G, 0 < orderOf g) :
exponent G = 0 ↔ (Set.range (orderOf : G → ℕ)).Infinite := by
have := exponent_ne_zero_iff_range_orderOf_finite h
rwa [Ne, not_iff_comm, Iff.comm] at this
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_zero_iff_range_orderOf_infinite | null |
lcm_orderOf_eq_exponent [Fintype G] : (Finset.univ : Finset G).lcm orderOf = exponent G :=
Nat.dvd_antisymm
(lcm_orderOf_dvd_exponent G)
(exponent_dvd.mpr fun g => Finset.dvd_lcm (Finset.mem_univ g))
variable {H : Type*} [Monoid H] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | lcm_orderOf_eq_exponent | null |
@[to_additive /-- If there exists an injective, addition-preserving map from `G` to `H`,
then the exponent of `G` divides the exponent of `H`. -/]
exponent_dvd_of_monoidHom (e : G →* H) (e_inj : Function.Injective e) :
Monoid.exponent G ∣ Monoid.exponent H :=
exponent_dvd_of_forall_pow_eq_one fun g => e_inj (by
rw [map_pow, pow_exponent_eq_one, map_one]) | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_dvd_of_monoidHom | If there exists an injective, multiplication-preserving map from `G` to `H`,
then the exponent of `G` divides the exponent of `H`. |
@[to_additive /-- If there exists a addition-preserving equivalence between `G` and `H`,
then the exponent of `G` is equal to the exponent of `H`. -/]
exponent_eq_of_mulEquiv (e : G ≃* H) : Monoid.exponent G = Monoid.exponent H :=
Nat.dvd_antisymm
(exponent_dvd_of_monoidHom e e.injective)
(exponent_dvd_of_monoidHom e.symm e.symm.injective) | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_of_mulEquiv | If there exists a multiplication-preserving equivalence between `G` and `H`,
then the exponent of `G` is equal to the exponent of `H`. |
@[to_additive (attr := simp)]
_root_.Submonoid.exponent_top :
Monoid.exponent (⊤ : Submonoid G) = Monoid.exponent G :=
exponent_eq_of_mulEquiv Submonoid.topEquiv
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | _root_.Submonoid.exponent_top | null |
_root_.Submonoid.pow_exponent_eq_one {S : Submonoid G} {g : G} (g_in_s : g ∈ S) :
g ^ (Monoid.exponent S) = 1 := by
have := Monoid.pow_exponent_eq_one (⟨g, g_in_s⟩ : S)
rwa [SubmonoidClass.mk_pow, ← OneMemClass.coe_eq_one] at this | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | _root_.Submonoid.pow_exponent_eq_one | null |
@[to_additive]
ExponentExists.of_finite : ExponentExists G := by
let _inst := Fintype.ofFinite G
simp only [Monoid.ExponentExists]
refine ⟨(Finset.univ : Finset G).lcm orderOf, ?_, fun g => ?_⟩
· simpa [pos_iff_ne_zero, Finset.lcm_eq_zero_iff] using fun x => (_root_.orderOf_pos x).ne'
· rw [← orderOf_dvd_iff_pow_eq_one, lcm_orderOf_eq_exponent]
exact order_dvd_exponent g
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | ExponentExists.of_finite | null |
exponent_ne_zero_of_finite : exponent G ≠ 0 :=
ExponentExists.of_finite.exponent_ne_zero
@[to_additive AddMonoid.one_lt_exponent] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_ne_zero_of_finite | null |
one_lt_exponent [Nontrivial G] : 1 < Monoid.exponent G := by
rw [Nat.one_lt_iff_ne_zero_and_ne_one]
exact ⟨exponent_ne_zero_of_finite, mt exp_eq_one_iff.mp (not_subsingleton G)⟩
@[to_additive] | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | one_lt_exponent | null |
neZero_exponent_of_finite : NeZero <| Monoid.exponent G :=
⟨Monoid.exponent_ne_zero_of_finite⟩ | instance | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | neZero_exponent_of_finite | null |
@[to_additive]
exists_orderOf_eq_exponent (hG : ExponentExists G) : ∃ g : G, orderOf g = exponent G := by
have he := hG.exponent_ne_zero
have hne : (Set.range (orderOf : G → ℕ)).Nonempty := ⟨1, 1, orderOf_one⟩
have hfin : (Set.range (orderOf : G → ℕ)).Finite := by
rwa [← exponent_ne_zero_iff_range_orderOf_finite hG.orderOf_pos]
obtain ⟨t, ht⟩ := hne.csSup_mem hfin
use t
apply Nat.dvd_antisymm (order_dvd_exponent _)
refine Nat.dvd_of_primeFactorsList_subperm he ?_
rw [List.subperm_ext_iff]
by_contra! h
obtain ⟨p, hp, hpe⟩ := h
replace hp := Nat.prime_of_mem_primeFactorsList hp
simp only [Nat.primeFactorsList_count_eq] at hpe
set k := (orderOf t).factorization p with hk
obtain ⟨g, hg⟩ := hp.exists_orderOf_eq_pow_factorization_exponent G
suffices orderOf t < orderOf (t ^ p ^ k * g) by
rw [ht] at this
exact this.not_ge (le_csSup hfin.bddAbove <| Set.mem_range_self _)
have hpk : p ^ k ∣ orderOf t := Nat.ordProj_dvd _ _
have hpk' : orderOf (t ^ p ^ k) = orderOf t / p ^ k := by
rw [orderOf_pow' t (pow_ne_zero k hp.ne_zero), Nat.gcd_eq_right hpk]
obtain ⟨a, ha⟩ := Nat.exists_eq_add_of_lt hpe
have hcoprime : (orderOf (t ^ p ^ k)).Coprime (orderOf g) := by
rw [hg, Nat.coprime_pow_right_iff (pos_of_gt hpe), Nat.coprime_comm]
apply Or.resolve_right (Nat.coprime_or_dvd_of_prime hp _)
nth_rw 1 [← pow_one p]
have : 1 = (Nat.factorization (orderOf (t ^ p ^ k))) p + 1 := by
rw [hpk', Nat.factorization_div hpk]
simp [k, hp]
rw [this]
exact Nat.pow_succ_factorization_not_dvd (hG.orderOf_pos <| t ^ p ^ k).ne' hp
rw [(Commute.all _ g).orderOf_mul_eq_mul_orderOf_of_coprime hcoprime, hpk',
hg, ha, hk, pow_add, pow_add, pow_one, ← mul_assoc, ← mul_assoc,
Nat.div_mul_cancel, mul_assoc, lt_mul_iff_one_lt_right <| hG.orderOf_pos t, ← pow_succ]
· exact one_lt_pow₀ hp.one_lt a.succ_ne_zero
· exact hpk
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exists_orderOf_eq_exponent | null |
exponent_eq_iSup_orderOf (h : ∀ g : G, 0 < orderOf g) :
exponent G = ⨆ g : G, orderOf g := by
rw [iSup]
by_cases ExponentExists G
case neg he =>
rw [← exponent_eq_zero_iff] at he
rw [he, Set.Infinite.Nat.sSup_eq_zero <| (exponent_eq_zero_iff_range_orderOf_infinite h).1 he]
case pos he =>
rw [csSup_eq_of_forall_le_of_forall_lt_exists_gt (Set.range_nonempty _)]
· simp_rw [Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff]
exact orderOf_le_exponent he
intro x hx
obtain ⟨g, hg⟩ := exists_orderOf_eq_exponent he
rw [← hg] at hx
simp_rw [Set.mem_range, exists_exists_eq_and]
exact ⟨g, hx⟩
open scoped Classical in
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_iSup_orderOf | null |
exponent_eq_iSup_orderOf' :
exponent G = if ∃ g : G, orderOf g = 0 then 0 else ⨆ g : G, orderOf g := by
split_ifs with h
· obtain ⟨g, hg⟩ := h
exact exponent_eq_zero_of_order_zero hg
· have := not_exists.mp h
exact exponent_eq_iSup_orderOf fun g => Ne.bot_lt <| this g | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_iSup_orderOf' | null |
@[to_additive]
exponent_eq_max'_orderOf [Fintype G] :
exponent G = ((@Finset.univ G _).image orderOf).max' ⟨1, by simp⟩ := by
rw [← Finset.Nonempty.csSup_eq_max', Finset.coe_image, Finset.coe_univ, Set.image_univ, ← iSup]
exact exponent_eq_iSup_orderOf orderOf_pos | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | exponent_eq_max'_orderOf | null |
@[to_additive]
Group.exponent_dvd_card [Fintype G] : Monoid.exponent G ∣ Fintype.card G :=
Monoid.exponent_dvd.mpr <| fun _ => orderOf_dvd_card
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Group.exponent_dvd_card | null |
Group.exponent_dvd_nat_card : Monoid.exponent G ∣ Nat.card G :=
Monoid.exponent_dvd.mpr orderOf_dvd_natCard
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Group.exponent_dvd_nat_card | null |
Subgroup.exponent_toSubmonoid (H : Subgroup G) :
Monoid.exponent H.toSubmonoid = Monoid.exponent H :=
Monoid.exponent_eq_of_mulEquiv (MulEquiv.subgroupCongr rfl)
@[to_additive (attr := simp)] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Subgroup.exponent_toSubmonoid | null |
Subgroup.exponent_top : Monoid.exponent (⊤ : Subgroup G) = Monoid.exponent G :=
Monoid.exponent_eq_of_mulEquiv topEquiv
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Subgroup.exponent_top | null |
Subgroup.pow_exponent_eq_one {H : Subgroup G} {g : G} (g_in_H : g ∈ H) :
g ^ Monoid.exponent H = 1 := exponent_toSubmonoid H ▸ Submonoid.pow_exponent_eq_one g_in_H
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Subgroup.pow_exponent_eq_one | null |
Group.exponent_dvd_iff_forall_zpow_eq_one :
(Monoid.exponent G : ℤ) ∣ n ↔ ∀ g : G, g ^ n = 1 := by
simp_rw [Int.natCast_dvd, Monoid.exponent_dvd_iff_forall_pow_eq_one, pow_natAbs_eq_one]
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Group.exponent_dvd_iff_forall_zpow_eq_one | null |
Group.exponent_dvd_sub_iff_zpow_eq_zpow :
(Monoid.exponent G : ℤ) ∣ n - m ↔ ∀ g : G, g ^ n = g ^ m := by
simp_rw [Group.exponent_dvd_iff_forall_zpow_eq_one, zpow_sub, mul_inv_eq_one] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Group.exponent_dvd_sub_iff_zpow_eq_zpow | null |
@[to_additive]
Monoid.exponent_pi_eq_zero {ι : Type*} {M : ι → Type*} [∀ i, Monoid (M i)] {j : ι}
(hj : exponent (M j) = 0) : exponent ((i : ι) → M i) = 0 := by
classical
rw [@exponent_eq_zero_iff, ExponentExists] at hj ⊢
push_neg at hj ⊢
peel hj with n hn _
obtain ⟨m, hm⟩ := this
refine ⟨Pi.mulSingle j m, fun h ↦ hm ?_⟩
simpa using congr_fun h j | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Monoid.exponent_pi_eq_zero | null |
@[to_additive]
MonoidHom.exponent_dvd {F M₁ M₂ : Type*} [Monoid M₁] [Monoid M₂]
[FunLike F M₁ M₂] [MonoidHomClass F M₁ M₂]
{f : F} (hf : Function.Surjective f) : exponent M₂ ∣ exponent M₁ := by
refine Monoid.exponent_dvd_of_forall_pow_eq_one fun m₂ ↦ ?_
obtain ⟨m₁, rfl⟩ := hf m₂
rw [← map_pow, pow_exponent_eq_one, map_one] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | MonoidHom.exponent_dvd | If `f : M₁ →⋆ M₂` is surjective, then the exponent of `M₂` divides the exponent of `M₁`. |
@[to_additive /-- The exponent of finite product of additive monoids is the `Finset.lcm` of the
exponents of the constituent additive monoids. -/]
Monoid.exponent_pi {ι : Type*} [Fintype ι] {M : ι → Type*} [∀ i, Monoid (M i)] :
exponent ((i : ι) → M i) = lcm univ (exponent <| M ·) := by
refine dvd_antisymm ?_ ?_
· refine exponent_dvd_of_forall_pow_eq_one fun m ↦ ?_
ext i
rw [Pi.pow_apply, Pi.one_apply, ← orderOf_dvd_iff_pow_eq_one]
apply dvd_trans (Monoid.order_dvd_exponent (m i))
exact Finset.dvd_lcm (mem_univ i)
· apply Finset.lcm_dvd fun i _ ↦ ?_
exact MonoidHom.exponent_dvd (f := Pi.evalMonoidHom (M ·) i) (Function.surjective_eval i) | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Monoid.exponent_pi | The exponent of finite product of monoids is the `Finset.lcm` of the exponents of the
constituent monoids. |
@[to_additive AddMonoid.exponent_prod /-- The exponent of product of two additive monoids is the
`lcm` of the exponents of the individual additive monoids. -/]
Monoid.exponent_prod {M₁ M₂ : Type*} [Monoid M₁] [Monoid M₂] :
exponent (M₁ × M₂) = lcm (exponent M₁) (exponent M₂) := by
refine dvd_antisymm ?_ (lcm_dvd ?_ ?_)
· refine exponent_dvd_of_forall_pow_eq_one fun g ↦ ?_
ext1
· rw [Prod.pow_fst, Prod.fst_one, ← orderOf_dvd_iff_pow_eq_one]
exact dvd_trans (Monoid.order_dvd_exponent (g.1)) <| dvd_lcm_left _ _
· rw [Prod.pow_snd, Prod.snd_one, ← orderOf_dvd_iff_pow_eq_one]
exact dvd_trans (Monoid.order_dvd_exponent (g.2)) <| dvd_lcm_right _ _
· exact MonoidHom.exponent_dvd (f := MonoidHom.fst M₁ M₂) Prod.fst_surjective
· exact MonoidHom.exponent_dvd (f := MonoidHom.snd M₁ M₂) Prod.snd_surjective | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Monoid.exponent_prod | The exponent of product of two monoids is the `lcm` of the exponents of the
individual monoids. |
@[to_additive]
orderOf_eq_two_iff (hG : Monoid.exponent G = 2) {x : G} :
orderOf x = 2 ↔ x ≠ 1 :=
⟨by rintro hx rfl; norm_num at hx, orderOf_eq_prime (hG ▸ Monoid.pow_exponent_eq_one x)⟩
@[to_additive] | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | orderOf_eq_two_iff | null |
Commute.of_orderOf_dvd_two [IsCancelMul G] (h : ∀ g : G, orderOf g ∣ 2) (a b : G) :
Commute a b := by
simp_rw [orderOf_dvd_iff_pow_eq_one] at h
rw [commute_iff_eq, ← mul_right_inj a, ← mul_left_inj b]
calc
a * (a * b) * b = a ^ 2 * b ^ 2 := by simp [pow_two, mul_assoc]
_ = 1 := by rw [h, h, mul_one]
_ = (a * b) ^ 2 := by rw [h]
_ = a * (b * a) * b := by simp [pow_two, mul_assoc] | theorem | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | Commute.of_orderOf_dvd_two | null |
@[to_additive]
mul_comm_of_exponent_two [IsCancelMul G] (hG : Monoid.exponent G = 2) (a b : G) :
a * b = b * a :=
Commute.of_orderOf_dvd_two (fun g => hG ▸ Monoid.order_dvd_exponent g) a b | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | mul_comm_of_exponent_two | In a cancellative monoid of exponent two, all elements commute. |
@[to_additive /-- Any additive group of exponent two is abelian. -/]
commMonoidOfExponentTwo [IsCancelMul G] (hG : Monoid.exponent G = 2) : CommMonoid G where
mul_comm := mul_comm_of_exponent_two hG | abbrev | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | commMonoidOfExponentTwo | Any cancellative monoid of exponent two is abelian. |
@[to_additive]
inv_eq_self_of_exponent_two (hG : Monoid.exponent G = 2) (x : G) :
x⁻¹ = x :=
inv_eq_of_mul_eq_one_left <| pow_two (a := x) ▸ hG ▸ Monoid.pow_exponent_eq_one x | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | inv_eq_self_of_exponent_two | In a group of exponent two, every element is its own inverse. |
@[to_additive]
inv_eq_self_of_orderOf_eq_two {x : G} (hx : orderOf x = 2) :
x⁻¹ = x :=
inv_eq_of_mul_eq_one_left <| pow_two (a := x) ▸ hx ▸ pow_orderOf_eq_one x
@[to_additive] | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | inv_eq_self_of_orderOf_eq_two | If an element in a group has order two, then it is its own inverse. |
mul_notMem_of_orderOf_eq_two {x y : G} (hx : orderOf x = 2)
(hy : orderOf y = 2) (hxy : x ≠ y) : x * y ∉ ({x, y, 1} : Set G) := by
simp only [Set.mem_singleton_iff, Set.mem_insert_iff, mul_eq_left, mul_eq_right,
mul_eq_one_iff_eq_inv, inv_eq_self_of_orderOf_eq_two hy, not_or]
aesop
@[deprecated (since := "2025-05-23")]
alias add_not_mem_of_addOrderOf_eq_two := add_notMem_of_addOrderOf_eq_two
@[to_additive existing, deprecated (since := "2025-05-23")]
alias mul_not_mem_of_orderOf_eq_two := mul_notMem_of_orderOf_eq_two
@[to_additive] | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | mul_notMem_of_orderOf_eq_two | null |
mul_notMem_of_exponent_two (h : Monoid.exponent G = 2) {x y : G}
(hx : x ≠ 1) (hy : y ≠ 1) (hxy : x ≠ y) : x * y ∉ ({x, y, 1} : Set G) :=
mul_notMem_of_orderOf_eq_two (orderOf_eq_prime (h ▸ Monoid.pow_exponent_eq_one x) hx)
(orderOf_eq_prime (h ▸ Monoid.pow_exponent_eq_one y) hy) hxy
@[deprecated (since := "2025-05-23")]
alias add_not_mem_of_exponent_two := add_notMem_of_exponent_two
@[to_additive existing, deprecated (since := "2025-05-23")]
alias mul_not_mem_of_exponent_two := mul_notMem_of_exponent_two | lemma | GroupTheory | [
"Mathlib.Algebra.GCDMonoid.Finset",
"Mathlib.Algebra.GCDMonoid.Nat",
"Mathlib.Algebra.Order.BigOperators.Ring.Finset",
"Mathlib.Data.Nat.Factorization.LCM",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Tactic.Peel"
] | Mathlib/GroupTheory/Exponent.lean | mul_notMem_of_exponent_two | null |
@[to_additive /-- An additive submonoid of `N` is finitely generated if it is the closure of a
finite subset of `M`. -/]
Submonoid.FG (P : Submonoid M) : Prop :=
∃ S : Finset M, Submonoid.closure ↑S = P | def | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG | A submonoid of `M` is finitely generated if it is the closure of a finite subset of `M`. |
@[to_additive /-- An equivalent expression of `AddSubmonoid.FG` in terms of `Set.Finite` instead of
`Finset`. -/]
Submonoid.fg_iff (P : Submonoid M) :
Submonoid.FG P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite :=
⟨fun ⟨S, hS⟩ => ⟨S, hS, Finset.finite_toSet S⟩, fun ⟨S, hS, hf⟩ =>
⟨Set.Finite.toFinset hf, by simp [hS]⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.fg_iff | An equivalent expression of `Submonoid.FG` in terms of `Set.Finite` instead of `Finset`. |
@[to_additive /-- A finitely generated submonoid has a minimal generating set. -/]
Submonoid.FG.exists_minimal_closure_eq (hP : P.FG) :
∃ S : Finset M, Minimal (closure ·.toSet = P) S := exists_minimal_of_wellFoundedLT _ hP | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.exists_minimal_closure_eq | A finitely generated submonoid has a minimal generating set. |
Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG :=
⟨fun h =>
let ⟨S, hS, hf⟩ := (Submonoid.fg_iff _).1 h
(AddSubmonoid.fg_iff _).mpr
⟨Additive.toMul ⁻¹' S, by simp [← Submonoid.toAddSubmonoid_closure, hS], hf⟩,
fun h =>
let ⟨T, hT, hf⟩ := (AddSubmonoid.fg_iff _).1 h
(Submonoid.fg_iff _).mpr
⟨Additive.ofMul ⁻¹' T, by simp [← AddSubmonoid.toSubmonoid'_closure, hT], hf⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.fg_iff_add_fg | null |
AddSubmonoid.fg_iff_mul_fg {M : Type*} [AddMonoid M] (P : AddSubmonoid M) :
P.FG ↔ P.toSubmonoid.FG := by
convert (Submonoid.fg_iff_add_fg (toSubmonoid P)).symm
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddSubmonoid.fg_iff_mul_fg | null |
Submonoid.FG.bot : FG (⊥ : Submonoid M) :=
⟨∅, by simp⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.bot | null |
Submonoid.FG.sup {Q : Submonoid M} (hP : P.FG) (hQ : Q.FG) : (P ⊔ Q).FG := by
classical
rcases hP with ⟨s, rfl⟩
rcases hQ with ⟨t, rfl⟩
exact ⟨s ∪ t, by simp [closure_union]⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.sup | null |
Submonoid.FG.finset_sup {ι : Type*} (s : Finset ι) (P : ι → Submonoid M)
(hP : ∀ i ∈ s, (P i).FG) : (s.sup P).FG :=
Finset.sup_induction bot (fun _ ha _ hb => ha.sup hb) hP
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.finset_sup | null |
Submonoid.FG.biSup_finset {ι : Type*} (s : Finset ι) (P : ι → Submonoid M)
(hP : ∀ i ∈ s, (P i).FG) : (⨆ i ∈ s, P i).FG := by
simpa only [Finset.sup_eq_iSup] using finset_sup s P hP
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.biSup_finset | null |
Submonoid.FG.biSup {ι : Type*} {s : Set ι} (hs : s.Finite) (P : ι → Submonoid M)
(hP : ∀ i ∈ s, (P i).FG) : (⨆ i ∈ s, P i).FG := by
simpa using biSup_finset hs.toFinset P (by simpa)
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.biSup | null |
Submonoid.FG.iSup {ι : Sort*} [Finite ι] (P : ι → Submonoid M) (hP : ∀ i, (P i).FG) :
(iSup P).FG := by
simpa [iSup_plift_down] using biSup Set.finite_univ (P ∘ PLift.down) fun i _ => hP i.down | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.iSup | null |
@[to_additive prod
/-- The product of two finitely generated additive submonoids is finitely generated. -/]
Submonoid.FG.prod (hP : P.FG) (hQ : Q.FG) : (P.prod Q).FG := by
classical
obtain ⟨bM, hbM⟩ := hP
obtain ⟨bN, hbN⟩ := hQ
refine ⟨bM ×ˢ singleton 1 ∪ singleton 1 ×ˢ bN, ?_⟩
push_cast
simp [closure_union, hbM, hbN]
@[deprecated (since := "2025-08-28")] alias AddSubmonoid.FG.sum := AddSubmonoid.FG.prod | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.prod | The product of two finitely generated submonoids is finitely generated. |
@[to_additive]
Submonoid.iSup_map_mulSingle [DecidableEq ι] :
⨆ i, map (MonoidHom.mulSingle M i) (P i) = pi Set.univ P := by
haveI := Fintype.ofFinite ι
refine iSup_map_mulSingle_le.antisymm fun x hx => ?_
rw [← Finset.noncommProd_mul_single x]
exact noncommProd_mem _ _ _ _ fun i _ => mem_iSup_of_mem _ (mem_map_of_mem _ (hx i trivial)) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.iSup_map_mulSingle | null |
@[to_additive
/-- Finite product of finitely generated additive submonoids is finitely generated. -/]
Submonoid.FG.pi (hP : ∀ i, (P i).FG) : (pi Set.univ P).FG := by
classical
haveI := Fintype.ofFinite ι
choose s hs using hP
refine ⟨Finset.univ.biUnion fun i => (s i).image (MonoidHom.mulSingle M i), ?_⟩
simp_rw [Finset.coe_biUnion, Finset.coe_univ, Set.biUnion_univ, closure_iUnion, Finset.coe_image,
← MonoidHom.map_mclosure, hs, iSup_map_mulSingle] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.pi | Finite product of finitely generated submonoids is finitely generated. |
@[mk_iff]
AddMonoid.FG (M : Type*) [AddMonoid M] : Prop where
fg_top : (⊤ : AddSubmonoid M).FG
variable (M) in | class | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddMonoid.FG | An additive monoid is finitely generated if it is finitely generated as an additive submonoid of
itself. |
@[to_additive]
Monoid.FG : Prop where
fg_top : (⊤ : Submonoid M).FG
@[to_additive] | class | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.FG | A monoid is finitely generated if it is finitely generated as a submonoid of itself. |
Monoid.fg_def : Monoid.FG M ↔ (⊤ : Submonoid M).FG :=
⟨fun h => h.1, fun h => ⟨h⟩⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_def | null |
@[to_additive
/-- An equivalent expression of `AddMonoid.FG` in terms of `Set.Finite` instead of `Finset`. -/]
Monoid.fg_iff :
Monoid.FG M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite :=
⟨fun _ => (Submonoid.fg_iff ⊤).1 FG.fg_top, fun h => ⟨(Submonoid.fg_iff ⊤).2 h⟩⟩
variable (M) in | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_iff | An equivalent expression of `Monoid.FG` in terms of `Set.Finite` instead of `Finset`. |
@[to_additive /-- A finitely generated monoid has a minimal generating set. -/]
Submonoid.exists_minimal_closure_eq_top [Monoid.FG M] :
∃ S : Finset M, Minimal (Submonoid.closure ·.toSet = ⊤) S :=
Monoid.FG.fg_top.exists_minimal_closure_eq | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.exists_minimal_closure_eq_top | A finitely generated monoid has a minimal generating set. |
Monoid.fg_iff_add_fg : Monoid.FG M ↔ AddMonoid.FG (Additive M) where
mp _ := ⟨(Submonoid.fg_iff_add_fg ⊤).1 FG.fg_top⟩
mpr h := ⟨(Submonoid.fg_iff_add_fg ⊤).2 h.fg_top⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_iff_add_fg | null |
AddMonoid.fg_iff_mul_fg {M : Type*} [AddMonoid M] :
AddMonoid.FG M ↔ Monoid.FG (Multiplicative M) where
mp _ := ⟨(AddSubmonoid.fg_iff_mul_fg ⊤).1 FG.fg_top⟩
mpr h := ⟨(AddSubmonoid.fg_iff_mul_fg ⊤).2 h.fg_top⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddMonoid.fg_iff_mul_fg | null |
AddMonoid.fg_of_monoid_fg [Monoid.FG M] : AddMonoid.FG (Additive M) :=
Monoid.fg_iff_add_fg.1 ‹_› | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | AddMonoid.fg_of_monoid_fg | null |
Monoid.fg_of_addMonoid_fg {M : Type*} [AddMonoid M] [AddMonoid.FG M] :
Monoid.FG (Multiplicative M) :=
AddMonoid.fg_iff_mul_fg.1 ‹_›
@[to_additive] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_of_addMonoid_fg | null |
Monoid.fg_of_finite [Finite M] : Monoid.FG M := by
cases nonempty_fintype M
exact ⟨⟨Finset.univ, by rw [Finset.coe_univ]; exact Submonoid.closure_univ⟩⟩ | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Monoid.fg_of_finite | null |
@[to_additive]
Submonoid.FG.map {M' : Type*} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
(P.map e).FG := by
classical
obtain ⟨s, rfl⟩ := h
exact ⟨s.image e, by rw [Finset.coe_image, MonoidHom.map_mclosure]⟩
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Set.Finite",
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.Algebra.Group.Submonoid.BigOperators",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/Finiteness.lean | Submonoid.FG.map | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.