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 ⌀ |
|---|---|---|---|---|---|---|
noncomputable equiv [Fact p.Prime] [Finite (Sylow p G)] (P Q : Sylow p G) : P ≃* Q := by
rw [← Classical.choose_spec (exists_smul_eq G P Q)]
exact P.equivSMul (Classical.choose (exists_smul_eq G P Q))
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | equiv | Sylow subgroups are isomorphic -/
nonrec def equivSMul (P : Sylow p G) (g : G) : P ≃* (g • P : Sylow p G) :=
equivSMul (MulAut.conj g) P.toSubgroup
/-- Sylow subgroups are isomorphic |
orbit_eq_top [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G) : orbit G P = ⊤ :=
top_le_iff.mp fun Q _ => exists_smul_eq G P Q | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | orbit_eq_top | null |
stabilizer_eq_normalizer (P : Sylow p G) :
stabilizer G P = P.normalizer := by
ext; simp [smul_eq_iff_mem_normalizer] | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | stabilizer_eq_normalizer | null |
conj_eq_normalizer_conj_of_mem_centralizer [Fact p.Prime] [Finite (Sylow p G)]
(P : Sylow p G) (x g : G) (hx : x ∈ centralizer P)
(hy : g⁻¹ * x * g ∈ centralizer P) :
∃ n ∈ P.normalizer, g⁻¹ * x * g = n⁻¹ * x * n := by
have h1 : P ≤ centralizer (zpowers x : Set G) := by rwa [le_centralizer_iff, zpowers_le]
have h2 : ↑(g • P) ≤ centralizer (zpowers x : Set G) := by
rw [le_centralizer_iff, zpowers_le]
rintro - ⟨z, hz, rfl⟩
specialize hy z hz
rwa [← mul_assoc, ← eq_mul_inv_iff_mul_eq, mul_assoc, mul_assoc, mul_assoc, ← mul_assoc,
eq_inv_mul_iff_mul_eq, ← mul_assoc, ← mul_assoc] at hy
obtain ⟨h, hh⟩ :=
exists_smul_eq (centralizer (zpowers x : Set G)) ((g • P).subtype h2) (P.subtype h1)
simp_rw [smul_subtype, Subgroup.smul_def, smul_smul] at hh
refine ⟨h * g, smul_eq_iff_mem_normalizer.mp (subtype_injective hh), ?_⟩
rw [← mul_assoc, Commute.right_comm (h.prop x (mem_zpowers x)), mul_inv_rev, inv_mul_cancel_right] | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | conj_eq_normalizer_conj_of_mem_centralizer | null |
conj_eq_normalizer_conj_of_mem [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G)
[_hP : IsMulCommutative P] (x g : G) (hx : x ∈ P) (hy : g⁻¹ * x * g ∈ P) :
∃ n ∈ P.normalizer, g⁻¹ * x * g = n⁻¹ * x * n :=
P.conj_eq_normalizer_conj_of_mem_centralizer x g
(P.le_centralizer hx) (P.le_centralizer hy) | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | conj_eq_normalizer_conj_of_mem | null |
noncomputable equivQuotientNormalizer [Fact p.Prime] [Finite (Sylow p G)]
(P : Sylow p G) : Sylow p G ≃ G ⧸ P.normalizer :=
calc
Sylow p G ≃ (⊤ : Set (Sylow p G)) := (Equiv.Set.univ (Sylow p G)).symm
_ ≃ orbit G P := Equiv.setCongr P.orbit_eq_top.symm
_ ≃ G ⧸ stabilizer G P := orbitEquivQuotientStabilizer G P
_ ≃ G ⧸ P.normalizer := by rw [P.stabilizer_eq_normalizer] | def | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | equivQuotientNormalizer | Sylow `p`-subgroups are in bijection with cosets of the normalizer of a Sylow `p`-subgroup |
card_eq_card_quotient_normalizer [Fact p.Prime] [Finite (Sylow p G)]
(P : Sylow p G) : Nat.card (Sylow p G) = Nat.card (G ⧸ P.normalizer) :=
Nat.card_congr P.equivQuotientNormalizer | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | card_eq_card_quotient_normalizer | null |
card_eq_index_normalizer [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G) :
Nat.card (Sylow p G) = P.normalizer.index :=
P.card_eq_card_quotient_normalizer | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | card_eq_index_normalizer | null |
card_dvd_index [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G) :
Nat.card (Sylow p G) ∣ P.index :=
((congr_arg _ P.card_eq_index_normalizer).mp dvd_rfl).trans
(index_dvd_of_le le_normalizer) | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | card_dvd_index | null |
private not_dvd_index_aux [hp : Fact p.Prime] (P : Sylow p G) [P.Normal]
[P.FiniteIndex] : ¬ p ∣ P.index := by
intro h
rw [P.index_eq_card] at h
obtain ⟨x, hx⟩ := exists_prime_orderOf_dvd_card' (G := G ⧸ (P : Subgroup G)) p h
have h := IsPGroup.of_card (((Nat.card_zpowers x).trans hx).trans (pow_one p).symm)
let Q := (zpowers x).comap (QuotientGroup.mk' (P : Subgroup G))
have hQ : IsPGroup p Q := by
apply h.comap_of_ker_isPGroup
rw [QuotientGroup.ker_mk']
exact P.2
replace hp := mt orderOf_eq_one_iff.mpr (ne_of_eq_of_ne hx hp.1.ne_one)
rw [← zpowers_eq_bot, ← Ne, ← bot_lt_iff_ne_bot, ←
comap_lt_comap_of_surjective (QuotientGroup.mk'_surjective _), MonoidHom.comap_bot,
QuotientGroup.ker_mk'] at hp
exact hp.ne' (P.3 hQ hp.le) | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | not_dvd_index_aux | Auxiliary lemma for `Sylow.not_dvd_index` which is strictly stronger. |
not_dvd_index' [hp : Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G)
(hP : P.relIndex P.normalizer ≠ 0) : ¬ p ∣ P.index := by
rw [← relIndex_mul_index le_normalizer, ← card_eq_index_normalizer]
haveI : (P.subtype le_normalizer).Normal :=
Subgroup.normal_in_normalizer
haveI : (P.subtype le_normalizer).FiniteIndex := ⟨hP⟩
replace hP := not_dvd_index_aux (P.subtype le_normalizer)
exact hp.1.not_dvd_mul hP (not_dvd_card_sylow p G) | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | not_dvd_index' | A Sylow p-subgroup has index indivisible by `p`, assuming [N(P) : P] < ∞. |
not_dvd_index [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G) [P.FiniteIndex] :
¬ p ∣ P.index :=
P.not_dvd_index' Nat.card_pos.ne' | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | not_dvd_index | A Sylow p-subgroup has index indivisible by `p`. |
mapSurjective [Fact p.Prime] (P : Sylow p G) : Sylow p G' :=
{ P.1.map f with
isPGroup' := P.2.map f
is_maximal' := fun hQ hPQ ↦ ((P.2.map f).toSylow
(fun h ↦ P.not_dvd_index (h.trans (P.index_map_dvd hf)))).3 hQ hPQ }
@[simp] theorem coe_mapSurjective [Fact p.Prime] (P : Sylow p G) : P.mapSurjective hf = P.map f :=
rfl | def | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | mapSurjective | Surjective group homomorphisms map Sylow subgroups to Sylow subgroups. |
mapSurjective_surjective (p : ℕ) [Fact p.Prime] :
Function.Surjective (Sylow.mapSurjective hf : Sylow p G → Sylow p G') := by
have : Finite G' := Finite.of_surjective f hf
intro P
let Q₀ : Sylow p (P.comap f) := Sylow.nonempty.some
let Q : Subgroup G := Q₀.map (P.comap f).subtype
have hPQ : Q.map f ≤ P := Subgroup.map_le_iff_le_comap.mpr (Subgroup.map_subtype_le Q₀.1)
have hpQ : IsPGroup p Q := Q₀.2.map (P.comap f).subtype
have hQ : ¬ p ∣ Q.index := by
rw [Subgroup.index_map_subtype Q₀.1, P.index_comap_of_surjective hf]
exact Nat.Prime.not_dvd_mul Fact.out Q₀.not_dvd_index P.not_dvd_index
use hpQ.toSylow hQ
rw [Sylow.ext_iff, Sylow.coe_mapSurjective, eq_comm]
exact ((hpQ.map f).toSylow (fun h ↦ hQ (h.trans (Q.index_map_dvd hf)))).3 P.2 hPQ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | mapSurjective_surjective | null |
normalizer_sup_eq_top {p : ℕ} [Fact p.Prime] {N : Subgroup G} [N.Normal]
[Finite (Sylow p N)] (P : Sylow p N) :
(P.map N.subtype).normalizer ⊔ N = ⊤ := by
refine top_le_iff.mp fun g _ => ?_
obtain ⟨n, hn⟩ := exists_smul_eq N ((MulAut.conjNormal g : MulAut N) • P) P
rw [← inv_mul_cancel_left (↑n) g, sup_comm]
apply mul_mem_sup (N.inv_mem n.2)
rw [smul_def, ← mul_smul, ← MulAut.conjNormal_val, ← MulAut.conjNormal.map_mul,
Sylow.ext_iff, pointwise_smul_def, Subgroup.pointwise_smul_def] at hn
have : Function.Injective (MulAut.conj (n * g)).toMonoidHom := (MulAut.conj (n * g)).injective
refine fun x ↦ (mem_map_iff_mem this).symm.trans ?_
rw [map_map, ← congr_arg (map N.subtype) hn, map_map]
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | normalizer_sup_eq_top | **Frattini's Argument**: If `N` is a normal subgroup of `G`, and if `P` is a Sylow `p`-subgroup
of `N`, then `N_G(P) ⊔ N = G`. |
normalizer_sup_eq_top' {p : ℕ} [Fact p.Prime] {N : Subgroup G} [N.Normal]
[Finite (Sylow p N)] (P : Sylow p G) (hP : P ≤ N) : P.normalizer ⊔ N = ⊤ := by
rw [← normalizer_sup_eq_top (P.subtype hP), P.coe_subtype, subgroupOf_map_subtype,
inf_of_le_left hP] | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | normalizer_sup_eq_top' | **Frattini's Argument**: If `N` is a normal subgroup of `G`, and if `P` is a Sylow `p`-subgroup
of `N`, then `N_G(P) ⊔ N = G`. |
QuotientGroup.card_preimage_mk (s : Subgroup G) (t : Set (G ⧸ s)) :
Nat.card (QuotientGroup.mk ⁻¹' t) = Nat.card s * Nat.card t := by
rw [← Nat.card_prod, Nat.card_congr (preimageMkEquivSubgroupProdSet _ _)] | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | QuotientGroup.card_preimage_mk | null |
mem_fixedPoints_mul_left_cosets_iff_mem_normalizer {H : Subgroup G} [Finite (H : Set G)]
{x : G} : (x : G ⧸ H) ∈ MulAction.fixedPoints H (G ⧸ H) ↔ x ∈ normalizer H :=
⟨fun hx =>
have ha : ∀ {y : G ⧸ H}, y ∈ orbit H (x : G ⧸ H) → y = x := mem_fixedPoints'.1 hx _
(inv_mem_iff (G := G)).1
(mem_normalizer_fintype fun n (hn : n ∈ H) =>
have : (n⁻¹ * x)⁻¹ * x ∈ H := QuotientGroup.eq.1 (ha ⟨⟨n⁻¹, inv_mem hn⟩, rfl⟩)
show _ ∈ H by
rw [mul_inv_rev, inv_inv] at this
convert this
rw [inv_inv]),
fun hx : ∀ n : G, n ∈ H ↔ x * n * x⁻¹ ∈ H =>
mem_fixedPoints'.2 fun y =>
Quotient.inductionOn' y fun y hy =>
QuotientGroup.eq.2
(let ⟨⟨b, hb₁⟩, hb₂⟩ := hy
have hb₂ : (b * x)⁻¹ * y ∈ H := QuotientGroup.eq.1 hb₂
(inv_mem_iff (G := G)).1 <|
(hx _).2 <|
(mul_mem_cancel_left (inv_mem hb₁)).1 <| by
rw [hx] at hb₂; simpa [mul_inv_rev, mul_assoc] using hb₂)⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | mem_fixedPoints_mul_left_cosets_iff_mem_normalizer | null |
fixedPointsMulLeftCosetsEquivQuotient (H : Subgroup G) [Finite (H : Set G)] :
MulAction.fixedPoints H (G ⧸ H) ≃
normalizer H ⧸ Subgroup.comap ((normalizer H).subtype : normalizer H →* G) H :=
@subtypeQuotientEquivQuotientSubtype G (normalizer H : Set G) (_) (_)
(MulAction.fixedPoints H (G ⧸ H))
(fun _ => (@mem_fixedPoints_mul_left_cosets_iff_mem_normalizer _ _ _ ‹_› _).symm)
(by
intros
unfold_projs
rw [leftRel_apply (α := normalizer H), leftRel_apply]
rfl) | def | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | fixedPointsMulLeftCosetsEquivQuotient | The fixed points of the action of `H` on its cosets correspond to `normalizer H / H`. |
card_quotient_normalizer_modEq_card_quotient [Finite G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime]
{H : Subgroup G} (hH : Nat.card H = p ^ n) :
Nat.card (normalizer H ⧸ Subgroup.comap ((normalizer H).subtype : normalizer H →* G) H) ≡
Nat.card (G ⧸ H) [MOD p] := by
rw [← Nat.card_congr (fixedPointsMulLeftCosetsEquivQuotient H)]
exact ((IsPGroup.of_card hH).card_modEq_card_fixedPoints _).symm | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | card_quotient_normalizer_modEq_card_quotient | If `H` is a `p`-subgroup of `G`, then the index of `H` inside its normalizer is congruent
mod `p` to the index of `H`. |
card_normalizer_modEq_card [Finite G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime] {H : Subgroup G}
(hH : Nat.card H = p ^ n) : Nat.card (normalizer H) ≡ Nat.card G [MOD p ^ (n + 1)] := by
have : H.subgroupOf (normalizer H) ≃ H := (subgroupOfEquivOfLe le_normalizer).toEquiv
rw [card_eq_card_quotient_mul_card_subgroup H,
card_eq_card_quotient_mul_card_subgroup (H.subgroupOf (normalizer H)), Nat.card_congr this,
hH, pow_succ']
exact (card_quotient_normalizer_modEq_card_quotient hH).mul_right' _ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | card_normalizer_modEq_card | If `H` is a subgroup of `G` of cardinality `p ^ n`, then the cardinality of the
normalizer of `H` is congruent mod `p ^ (n + 1)` to the cardinality of `G`. |
prime_dvd_card_quotient_normalizer [Finite G] {p : ℕ} {n : ℕ} [Fact p.Prime]
(hdvd : p ^ (n + 1) ∣ Nat.card G) {H : Subgroup G} (hH : Nat.card H = p ^ n) :
p ∣ Nat.card (normalizer H ⧸ Subgroup.comap ((normalizer H).subtype : normalizer H →* G) H) :=
let ⟨s, hs⟩ := exists_eq_mul_left_of_dvd hdvd
have hcard : Nat.card (G ⧸ H) = s * p :=
(mul_left_inj' (show Nat.card H ≠ 0 from Nat.card_pos.ne')).1
(by
rw [← card_eq_card_quotient_mul_card_subgroup H, hH, hs, pow_succ', mul_assoc, mul_comm p])
have hm :
s * p % p =
Nat.card (normalizer H ⧸ Subgroup.comap ((normalizer H).subtype : normalizer H →* G) H) % p :=
hcard ▸ (card_quotient_normalizer_modEq_card_quotient hH).symm
Nat.dvd_of_mod_eq_zero (by rwa [Nat.mod_eq_zero_of_dvd (dvd_mul_left _ _), eq_comm] at hm) | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | prime_dvd_card_quotient_normalizer | If `H` is a `p`-subgroup but not a Sylow `p`-subgroup, then `p` divides the
index of `H` inside its normalizer. |
prime_pow_dvd_card_normalizer [Finite G] {p : ℕ} {n : ℕ} [_hp : Fact p.Prime]
(hdvd : p ^ (n + 1) ∣ Nat.card G) {H : Subgroup G} (hH : Nat.card H = p ^ n) :
p ^ (n + 1) ∣ Nat.card (normalizer H) :=
Nat.modEq_zero_iff_dvd.1 ((card_normalizer_modEq_card hH).trans hdvd.modEq_zero_nat) | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | prime_pow_dvd_card_normalizer | If `H` is a `p`-subgroup but not a Sylow `p`-subgroup of cardinality `p ^ n`,
then `p ^ (n + 1)` divides the cardinality of the normalizer of `H`. |
exists_subgroup_card_pow_succ [Finite G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime]
(hdvd : p ^ (n + 1) ∣ Nat.card G) {H : Subgroup G} (hH : Nat.card H = p ^ n) :
∃ K : Subgroup G, Nat.card K = p ^ (n + 1) ∧ H ≤ K :=
let ⟨s, hs⟩ := exists_eq_mul_left_of_dvd hdvd
have hcard : Nat.card (G ⧸ H) = s * p :=
(mul_left_inj' (show Nat.card H ≠ 0 from Nat.card_pos.ne')).1
(by
rw [← card_eq_card_quotient_mul_card_subgroup H, hH, hs, pow_succ', mul_assoc, mul_comm p])
have hm : s * p % p = Nat.card (normalizer H ⧸ H.subgroupOf H.normalizer) % p :=
Nat.card_congr (fixedPointsMulLeftCosetsEquivQuotient H) ▸
hcard ▸ (IsPGroup.of_card hH).card_modEq_card_fixedPoints _
have hm' : p ∣ Nat.card (normalizer H ⧸ H.subgroupOf H.normalizer) :=
Nat.dvd_of_mod_eq_zero (by rwa [Nat.mod_eq_zero_of_dvd (dvd_mul_left _ _), eq_comm] at hm)
let ⟨x, hx⟩ := @exists_prime_orderOf_dvd_card' _ (QuotientGroup.Quotient.group _) _ _ hp hm'
have hequiv : H ≃ H.subgroupOf H.normalizer := (subgroupOfEquivOfLe le_normalizer).symm.toEquiv
⟨Subgroup.map (normalizer H).subtype
(Subgroup.comap (mk' (H.subgroupOf H.normalizer)) (zpowers x)), by
show Nat.card (Subgroup.map H.normalizer.subtype
(comap (mk' (H.subgroupOf H.normalizer)) (Subgroup.zpowers x))) = p ^ (n + 1)
suffices Nat.card (Subtype.val ''
(Subgroup.comap (mk' (H.subgroupOf H.normalizer)) (zpowers x) : Set H.normalizer)) =
p ^ (n + 1)
by convert this using 2
rw [Nat.card_image_of_injective Subtype.val_injective
(Subgroup.comap (mk' (H.subgroupOf H.normalizer)) (zpowers x) : Set H.normalizer),
pow_succ, ← hH, Nat.card_congr hequiv, ← hx, ← Nat.card_zpowers, ←
Nat.card_prod]
exact Nat.card_congr
(preimageMkEquivSubgroupProdSet (H.subgroupOf H.normalizer) (zpowers x)), by
intro y hy
simp only [Subgroup.coe_subtype, mk'_apply, Subgroup.mem_map, Subgroup.mem_comap]
refine ⟨⟨y, le_normalizer hy⟩, ⟨0, ?_⟩, rfl⟩
dsimp only
rw [zpow_zero, eq_comm, QuotientGroup.eq_one_iff]
simpa using hy⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | exists_subgroup_card_pow_succ | If `H` is a subgroup of `G` of cardinality `p ^ n`,
then `H` is contained in a subgroup of cardinality `p ^ (n + 1)`
if `p ^ (n + 1)` divides the cardinality of `G` |
exists_subgroup_card_pow_prime_le [Finite G] (p : ℕ) :
∀ {n m : ℕ} [_hp : Fact p.Prime] (_hdvd : p ^ m ∣ Nat.card G) (H : Subgroup G)
(_hH : Nat.card H = p ^ n) (_hnm : n ≤ m), ∃ K : Subgroup G, Nat.card K = p ^ m ∧ H ≤ K
| n, m => fun {hdvd H hH hnm} =>
(lt_or_eq_of_le hnm).elim
(fun hnm : n < m =>
have h0m : 0 < m := lt_of_le_of_lt n.zero_le hnm
have hnm1 : n ≤ m - 1 := le_tsub_of_add_le_right hnm
let ⟨K, hK⟩ :=
@exists_subgroup_card_pow_prime_le _ _ n (m - 1) _
(Nat.pow_dvd_of_le_of_pow_dvd tsub_le_self hdvd) H hH hnm1
have hdvd' : p ^ (m - 1 + 1) ∣ Nat.card G := by rwa [tsub_add_cancel_of_le h0m.nat_succ_le]
let ⟨K', hK'⟩ := @exists_subgroup_card_pow_succ _ _ _ _ _ _ hdvd' K hK.1
⟨K', by rw [hK'.1, tsub_add_cancel_of_le h0m.nat_succ_le], le_trans hK.2 hK'.2⟩)
fun hnm : n = m => ⟨H, by simp [hH, hnm]⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | exists_subgroup_card_pow_prime_le | If `H` is a subgroup of `G` of cardinality `p ^ n`,
then `H` is contained in a subgroup of cardinality `p ^ m`
if `n ≤ m` and `p ^ m` divides the cardinality of `G` |
exists_subgroup_card_pow_prime [Finite G] (p : ℕ) {n : ℕ} [Fact p.Prime]
(hdvd : p ^ n ∣ Nat.card G) : ∃ K : Subgroup G, Nat.card K = p ^ n :=
let ⟨K, hK⟩ := exists_subgroup_card_pow_prime_le p hdvd ⊥
(by rw [card_bot, pow_zero]) n.zero_le
⟨K, hK.1⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | exists_subgroup_card_pow_prime | A generalisation of **Sylow's first theorem**. If `p ^ n` divides
the cardinality of `G`, then there is a subgroup of cardinality `p ^ n` |
exists_subgroup_card_pow_prime_of_le_card {n p : ℕ} (hp : p.Prime) (h : IsPGroup p G)
(hn : p ^ n ≤ Nat.card G) : ∃ H : Subgroup G, Nat.card H = p ^ n := by
have : Fact p.Prime := ⟨hp⟩
have : Finite G := Nat.finite_of_card_ne_zero <| by linarith [Nat.one_le_pow n p hp.pos]
obtain ⟨m, hm⟩ := h.exists_card_eq
refine exists_subgroup_card_pow_prime _ ?_
rw [hm] at hn ⊢
exact pow_dvd_pow _ <| (Nat.pow_le_pow_iff_right hp.one_lt).1 hn | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | exists_subgroup_card_pow_prime_of_le_card | A special case of **Sylow's first theorem**. If `G` is a `p`-group of size at least `p ^ n`
then there is a subgroup of cardinality `p ^ n`. |
exists_subgroup_le_card_pow_prime_of_le_card {n p : ℕ} (hp : p.Prime) (h : IsPGroup p G)
{H : Subgroup G} (hn : p ^ n ≤ Nat.card H) : ∃ H' ≤ H, Nat.card H' = p ^ n := by
obtain ⟨H', H'card⟩ := exists_subgroup_card_pow_prime_of_le_card hp (h.to_subgroup H) hn
refine ⟨H'.map H.subtype, map_subtype_le _, ?_⟩
rw [← H'card]
let e : H' ≃* H'.map H.subtype := H'.equivMapOfInjective (Subgroup.subtype H) H.subtype_injective
exact Nat.card_congr e.symm.toEquiv | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | exists_subgroup_le_card_pow_prime_of_le_card | A special case of **Sylow's first theorem**. If `G` is a `p`-group and `H` a subgroup of size at
least `p ^ n` then there is a subgroup of `H` of cardinality `p ^ n`. |
exists_subgroup_le_card_le {k p : ℕ} (hp : p.Prime) (h : IsPGroup p G) {H : Subgroup G}
(hk : k ≤ Nat.card H) (hk₀ : k ≠ 0) : ∃ H' ≤ H, Nat.card H' ≤ k ∧ k < p * Nat.card H' := by
obtain ⟨m, hmk, hkm⟩ : ∃ s, p ^ s ≤ k ∧ k < p ^ (s + 1) :=
exists_nat_pow_near (Nat.one_le_iff_ne_zero.2 hk₀) hp.one_lt
obtain ⟨H', H'H, H'card⟩ := exists_subgroup_le_card_pow_prime_of_le_card hp h (hmk.trans hk)
refine ⟨H', H'H, ?_⟩
simpa only [pow_succ', H'card] using And.intro hmk hkm | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | exists_subgroup_le_card_le | A special case of **Sylow's first theorem**. If `G` is a `p`-group and `H` a subgroup of size at
least `k` then there is a subgroup of `H` of cardinality between `k / p` and `k`. |
pow_dvd_card_of_pow_dvd_card [Finite G] {p n : ℕ} [hp : Fact p.Prime] (P : Sylow p G)
(hdvd : p ^ n ∣ Nat.card G) : p ^ n ∣ Nat.card P := by
rw [← index_mul_card P.1] at hdvd
exact (hp.1.coprime_pow_of_not_dvd P.not_dvd_index).symm.dvd_of_dvd_mul_left hdvd | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | pow_dvd_card_of_pow_dvd_card | null |
dvd_card_of_dvd_card [Finite G] {p : ℕ} [Fact p.Prime] (P : Sylow p G)
(hdvd : p ∣ Nat.card G) : p ∣ Nat.card P := by
rw [← pow_one p] at hdvd
have key := P.pow_dvd_card_of_pow_dvd_card hdvd
rwa [pow_one] at key | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | dvd_card_of_dvd_card | null |
card_coprime_index [Finite G] {p : ℕ} [hp : Fact p.Prime] (P : Sylow p G) :
(Nat.card P).Coprime P.index :=
let ⟨_n, hn⟩ := IsPGroup.iff_card.mp P.2
hn.symm ▸ (hp.1.coprime_pow_of_not_dvd P.not_dvd_index).symm | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | card_coprime_index | Sylow subgroups are Hall subgroups. |
ne_bot_of_dvd_card [Finite G] {p : ℕ} [hp : Fact p.Prime] (P : Sylow p G)
(hdvd : p ∣ Nat.card G) : (P : Subgroup G) ≠ ⊥ := by
refine fun h => hp.out.not_dvd_one ?_
have key : p ∣ Nat.card P := P.dvd_card_of_dvd_card hdvd
rwa [h, card_bot] at key | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | ne_bot_of_dvd_card | null |
card_eq_multiplicity [Finite G] {p : ℕ} [hp : Fact p.Prime] (P : Sylow p G) :
Nat.card P = p ^ Nat.factorization (Nat.card G) p := by
obtain ⟨n, heq : Nat.card P = _⟩ := IsPGroup.iff_card.mp P.isPGroup'
refine Nat.dvd_antisymm ?_ (P.pow_dvd_card_of_pow_dvd_card (Nat.ordProj_dvd _ p))
rw [heq, ← hp.out.pow_dvd_iff_dvd_ordProj (show Nat.card G ≠ 0 from Nat.card_pos.ne'), ← heq]
exact P.1.card_subgroup_dvd_card | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | card_eq_multiplicity | The cardinality of a Sylow subgroup is `p ^ n`
where `n` is the multiplicity of `p` in the group order. |
noncomputable unique_of_normal {p : ℕ} [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G)
(h : P.Normal) : Unique (Sylow p G) := by
refine { uniq := fun Q ↦ ?_ }
obtain ⟨x, h1⟩ := exists_smul_eq G P Q
obtain ⟨x, h2⟩ := exists_smul_eq G P default
rw [smul_eq_of_normal] at h1 h2
rw [← h1, ← h2] | def | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | unique_of_normal | If `G` has a normal Sylow `p`-subgroup, then it is the only Sylow `p`-subgroup. |
characteristic_of_subsingleton {p : ℕ} [Subsingleton (Sylow p G)] (P : Sylow p G) :
P.Characteristic := by
refine Subgroup.characteristic_iff_map_eq.mpr fun ϕ ↦ ?_
have h := Subgroup.pointwise_smul_def (a := ϕ) (P : Subgroup G)
rwa [← pointwise_smul_def, Subsingleton.elim (ϕ • P) P, eq_comm] at h | instance | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | characteristic_of_subsingleton | null |
normal_of_subsingleton {p : ℕ} [Subsingleton (Sylow p G)] (P : Sylow p G) :
P.Normal :=
Subgroup.normal_of_characteristic _ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | normal_of_subsingleton | null |
characteristic_of_normal {p : ℕ} [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G)
(h : P.Normal) : P.Characteristic := by
have _ := unique_of_normal P h
exact characteristic_of_subsingleton _ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | characteristic_of_normal | null |
normal_of_normalizer_normal {p : ℕ} [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G)
(hn : P.normalizer.Normal) : P.Normal := by
rw [← normalizer_eq_top_iff, ← normalizer_sup_eq_top' P le_normalizer, sup_idem]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | normal_of_normalizer_normal | null |
normalizer_normalizer {p : ℕ} [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G) :
P.normalizer.normalizer = P.normalizer := by
have := normal_of_normalizer_normal (P.subtype (le_normalizer.trans le_normalizer))
rw [coe_subtype, normal_subgroupOf_iff_le_normalizer (le_normalizer.trans le_normalizer),
← subgroupOf_normalizer_eq (le_normalizer.trans le_normalizer)] at this
exact le_antisymm (this normal_in_normalizer) le_normalizer | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | normalizer_normalizer | null |
normal_of_all_max_subgroups_normal [Finite G]
(hnc : ∀ H : Subgroup G, IsCoatom H → H.Normal) {p : ℕ} [Fact p.Prime] [Finite (Sylow p G)]
(P : Sylow p G) : P.Normal :=
normalizer_eq_top_iff.mp
(by
rcases eq_top_or_exists_le_coatom P.normalizer with (heq | ⟨K, hK, hNK⟩)
· exact heq
· haveI := hnc _ hK
have hPK : P ≤ K := le_trans le_normalizer hNK
refine (hK.1 ?_).elim
rw [← sup_of_le_right hNK, P.normalizer_sup_eq_top' hPK]) | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | normal_of_all_max_subgroups_normal | null |
normal_of_normalizerCondition (hnc : NormalizerCondition G) {p : ℕ} [Fact p.Prime]
[Finite (Sylow p G)] (P : Sylow p G) : P.Normal :=
normalizer_eq_top_iff.mp <|
normalizerCondition_iff_only_full_group_self_normalizing.mp hnc _ <| normalizer_normalizer _ | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | normal_of_normalizerCondition | null |
noncomputable directProductOfNormal [Finite G]
(hn : ∀ {p : ℕ} [Fact p.Prime] (P : Sylow p G), P.Normal) :
(∀ p : (Nat.card G).primeFactors, ∀ P : Sylow p G, P) ≃* G := by
have := Fintype.ofFinite G
set ps := (Nat.card G).primeFactors
let P : ∀ p, Sylow p G := default
have : ∀ p, Fintype (P p) := fun p ↦ Fintype.ofFinite (P p)
have hcomm : Pairwise fun p₁ p₂ : ps => ∀ x y : G, x ∈ P p₁ → y ∈ P p₂ → Commute x y := by
rintro ⟨p₁, hp₁⟩ ⟨p₂, hp₂⟩ hne
haveI hp₁' := Fact.mk (Nat.prime_of_mem_primeFactors hp₁)
haveI hp₂' := Fact.mk (Nat.prime_of_mem_primeFactors hp₂)
have hne' : p₁ ≠ p₂ := by simpa using hne
apply Subgroup.commute_of_normal_of_disjoint _ _ (hn (P p₁)) (hn (P p₂))
apply IsPGroup.disjoint_of_ne p₁ p₂ hne' _ _ (P p₁).isPGroup' (P p₂).isPGroup'
refine MulEquiv.trans (N := ∀ p : ps, P p) ?_ ?_
· -- here we need to help the elaborator with an explicit instantiation
apply @MulEquiv.piCongrRight ps (fun p => ∀ P : Sylow p G, P) (fun p => P p) _ _
rintro ⟨p, hp⟩
haveI hp' := Fact.mk (Nat.prime_of_mem_primeFactors hp)
letI := unique_of_normal _ (hn (P p))
apply MulEquiv.piUnique
apply MulEquiv.ofBijective (Subgroup.noncommPiCoprod hcomm)
apply (Fintype.bijective_iff_injective_and_card _).mpr
constructor
· apply Subgroup.injective_noncommPiCoprod_of_iSupIndep
apply independent_of_coprime_order hcomm
rintro ⟨p₁, hp₁⟩ ⟨p₂, hp₂⟩ hne
haveI hp₁' := Fact.mk (Nat.prime_of_mem_primeFactors hp₁)
haveI hp₂' := Fact.mk (Nat.prime_of_mem_primeFactors hp₂)
have hne' : p₁ ≠ p₂ := by simpa using hne
simp only [← Nat.card_eq_fintype_card]
apply IsPGroup.coprime_card_of_ne p₁ p₂ hne' _ _ (P p₁).isPGroup' (P p₂).isPGroup'
· simp only [← Nat.card_eq_fintype_card]
calc
Nat.card (∀ p : ps, P p) = ∏ p : ps, Nat.card (P p) := Nat.card_pi
_ = ∏ p : ps, p.1 ^ (Nat.card G).factorization p.1 := by
congr 1 with ⟨p, hp⟩
exact @card_eq_multiplicity _ _ _ p ⟨Nat.prime_of_mem_primeFactors hp⟩ (P p)
_ = ∏ p ∈ ps, p ^ (Nat.card G).factorization p :=
(Finset.prod_finset_coe (fun p => p ^ (Nat.card G).factorization p) _)
_ = (Nat.card G).factorization.prod (· ^ ·) := rfl
_ = Nat.card G := Nat.factorization_prod_pow_eq_self Nat.card_pos.ne' | def | GroupTheory | [
"Mathlib.Algebra.Order.Archimedean.Basic",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.GroupTheory.PGroup",
"Mathlib.GroupTheory.NoncommPiCoprod"
] | Mathlib/GroupTheory/Sylow.lean | directProductOfNormal | If all its Sylow subgroups are normal, then a finite group is isomorphic to the direct product
of these Sylow subgroups. |
@[to_additive
/-- A predicate on an additive monoid saying that all elements are of finite order. -/]
IsTorsion :=
∀ g : G, IsOfFinOrder g | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion | A predicate on a monoid saying that all elements are of finite order. |
@[to_additive (attr := simp) /-- An additive monoid is not a torsion monoid if it
has an element of infinite order. -/]
not_isTorsion_iff : ¬IsTorsion G ↔ ∃ g : G, ¬IsOfFinOrder g := by
rw [IsTorsion, not_forall] | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | not_isTorsion_iff | A monoid is not a torsion monoid if it has an element of infinite order. |
@[to_additive /-- Torsion additive monoids are really additive groups -/]
noncomputable IsTorsion.group [Monoid G] (tG : IsTorsion G) : Group G :=
{ ‹Monoid G› with
inv := fun g => g ^ (orderOf g - 1)
inv_mul_cancel := fun g => by
rw [← pow_succ, tsub_add_cancel_of_le, pow_orderOf_eq_one]
exact (tG g).orderOf_pos } | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.group | Torsion monoids are really groups. |
@[to_additive /-- Subgroups of additive torsion groups are additive torsion groups. -/]
IsTorsion.subgroup (tG : IsTorsion G) (H : Subgroup G) : IsTorsion H := fun h =>
Submonoid.isOfFinOrder_coe.1 <| tG h | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.subgroup | Subgroups of torsion groups are torsion groups. |
@[to_additive AddIsTorsion.of_surjective
/-- The image of a surjective additive torsion group homomorphism is torsion. -/]
IsTorsion.of_surjective {f : G →* H} (hf : Function.Surjective f) (tG : IsTorsion G) :
IsTorsion H := fun h => by
obtain ⟨g, hg⟩ := hf h
rw [← hg]
exact f.isOfFinOrder (tG g) | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.of_surjective | The image of a surjective torsion group homomorphism is torsion. |
@[to_additive AddIsTorsion.extension_closed
/-- Additive torsion groups are closed under extensions. -/]
IsTorsion.extension_closed {f : G →* H} (hN : N = f.ker) (tH : IsTorsion H)
(tN : IsTorsion N) : IsTorsion G := fun g => by
obtain ⟨ngn, ngnpos, hngn⟩ := (tH <| f g).exists_pow_eq_one
have hmem := MonoidHom.mem_ker.mpr ((f.map_pow g ngn).trans hngn)
lift g ^ ngn to N using hN.symm ▸ hmem with gn h
obtain ⟨nn, nnpos, hnn⟩ := (tN gn).exists_pow_eq_one
exact isOfFinOrder_iff_pow_eq_one.mpr <| ⟨ngn * nn, mul_pos ngnpos nnpos, by
rw [pow_mul, ← h, ← Subgroup.coe_pow, hnn, Subgroup.coe_one]⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.extension_closed | Torsion groups are closed under extensions. |
@[to_additive AddIsTorsion.quotient_iff
/-- The image of a quotient is additively torsion iff the group is torsion. -/]
IsTorsion.quotient_iff {f : G →* H} (hf : Function.Surjective f) (hN : N = f.ker)
(tN : IsTorsion N) : IsTorsion H ↔ IsTorsion G :=
⟨fun tH => IsTorsion.extension_closed hN tH tN, fun tG => IsTorsion.of_surjective hf tG⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.quotient_iff | The image of a quotient is torsion iff the group is torsion. |
@[to_additive ExponentExists.is_add_torsion
/-- If a group exponent exists, the group is additively torsion. -/]
ExponentExists.isTorsion (h : ExponentExists G) : IsTorsion G := fun g => by
obtain ⟨n, npos, hn⟩ := h
exact isOfFinOrder_iff_pow_eq_one.mpr ⟨n, npos, hn g⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | ExponentExists.isTorsion | If a group exponent exists, the group is torsion. |
@[to_additive IsAddTorsion.exponentExists
/-- The group exponent exists for any bounded additive torsion group. -/]
IsTorsion.exponentExists (tG : IsTorsion G)
(bounded : (Set.range fun g : G => orderOf g).Finite) : ExponentExists G :=
exponent_ne_zero.mp <|
(exponent_ne_zero_iff_range_orderOf_finite fun g => (tG g).orderOf_pos).mpr bounded | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.exponentExists | The group exponent exists for any bounded torsion group. |
@[to_additive is_add_torsion_of_finite /-- Finite additive groups are additive torsion groups. -/]
isTorsion_of_finite [Finite G] : IsTorsion G :=
ExponentExists.isTorsion .of_finite | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | isTorsion_of_finite | Finite groups are torsion groups. |
@[to_additive /-- A nontrivial additive torsion abelian group is not torsion-free. -/]
not_isMulTorsionFree_of_isTorsion [Nontrivial G] (hG : IsTorsion G) : ¬ IsMulTorsionFree G :=
not_isMulTorsionFree_iff_isOfFinOrder.2 <| let ⟨x, hx⟩ := exists_ne (1 : G); ⟨x, hx, hG x⟩ | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | not_isMulTorsionFree_of_isTorsion | A nontrivial torsion abelian group is not torsion-free. |
@[to_additive /-- A nontrivial additive torsion-free abelian group is not torsion. -/]
not_isTorsion_of_isMulTorsionFree [Nontrivial G] [IsMulTorsionFree G] : ¬ IsTorsion G :=
(not_isMulTorsionFree_of_isTorsion · ‹_›) | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | not_isTorsion_of_isMulTorsionFree | A nontrivial torsion-free abelian group is not torsion. |
IsTorsion.module_of_torsion [Semiring R] [Module R M] (tR : IsTorsion R) : IsTorsion M :=
fun f =>
isOfFinAddOrder_iff_nsmul_eq_zero.mpr <| by
obtain ⟨n, npos, hn⟩ := (tR 1).exists_nsmul_eq_zero
exact ⟨n, npos, by simp only [← Nat.cast_smul_eq_nsmul R _ f, ← nsmul_one, hn, zero_smul]⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.module_of_torsion | A module whose scalars are additively torsion is additively torsion. |
IsTorsion.module_of_finite [Ring R] [Finite R] [Module R M] : IsTorsion M :=
(is_add_torsion_of_finite : IsTorsion R).module_of_torsion _ _ | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.module_of_finite | A module with a finite ring of scalars is additively torsion. |
@[to_additive addTorsion /-- The torsion submonoid of an additive commutative monoid. -/]
torsion : Submonoid G where
carrier := { x | IsOfFinOrder x }
one_mem' := IsOfFinOrder.one
mul_mem' hx hy := hx.mul hy
variable {G} | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsion | The torsion submonoid of a commutative monoid.
(Note that by `Monoid.IsTorsion.group` torsion monoids are truthfully groups.) |
@[to_additive /-- Additive torsion submonoids are additively torsion. -/]
torsion.isTorsion : IsTorsion <| torsion G := fun ⟨x, n, npos, hn⟩ =>
⟨n, npos,
Subtype.ext <| by
dsimp
rw [mul_left_iterate]
change _ * 1 = 1
rw [_root_.mul_one, SubmonoidClass.coe_pow, Subtype.coe_mk,
(isPeriodicPt_mul_iff_pow_eq_one _).mp hn]⟩
variable (G) (p : ℕ) [hp : Fact p.Prime] | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsion.isTorsion | Torsion submonoids are torsion. |
@[to_additive (attr := simps)
/-- The `p`-primary component is the submonoid of elements with additive
order prime-power of `p`. -/]
primaryComponent : Submonoid G where
carrier := { g | ∃ n : ℕ, orderOf g = p ^ n }
one_mem' := ⟨0, by rw [pow_zero, orderOf_one]⟩
mul_mem' hg₁ hg₂ :=
exists_orderOf_eq_prime_pow_iff.mpr <| by
obtain ⟨m, hm⟩ := exists_orderOf_eq_prime_pow_iff.mp hg₁
obtain ⟨n, hn⟩ := exists_orderOf_eq_prime_pow_iff.mp hg₂
exact
⟨m + n, by
rw [mul_pow, pow_add, pow_mul, hm, one_pow, Monoid.one_mul, mul_comm, pow_mul, hn,
one_pow]⟩
variable {G} {p} | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | primaryComponent | The `p`-primary component is the submonoid of elements with order prime-power of `p`. |
@[to_additive primaryComponent.exists_orderOf_eq_prime_nsmul
/-- Elements of the `p`-primary component have additive order `p^n` for some `n` -/]
primaryComponent.exists_orderOf_eq_prime_pow (g : CommMonoid.primaryComponent G p) :
∃ n : ℕ, orderOf g = p ^ n := by
obtain ⟨_, hn⟩ := g.property
rw [orderOf_submonoid g] at hn
exact ⟨_, hn⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | primaryComponent.exists_orderOf_eq_prime_pow | Elements of the `p`-primary component have order `p^n` for some `n`. |
@[to_additive /-- The `p`- and `q`-primary components are disjoint for `p ≠ q`. -/]
primaryComponent.disjoint {p' : ℕ} [hp' : Fact p'.Prime] (hne : p ≠ p') :
Disjoint (CommMonoid.primaryComponent G p) (CommMonoid.primaryComponent G p') :=
Submonoid.disjoint_def.mpr <| by
rintro g ⟨_ | n, hn⟩ ⟨n', hn'⟩
· rwa [pow_zero, orderOf_eq_one_iff] at hn
· exact
absurd (eq_of_prime_pow_eq hp.out.prime hp'.out.prime n.succ_pos (hn.symm.trans hn')) hne | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | primaryComponent.disjoint | The `p`- and `q`-primary components are disjoint for `p ≠ q`. |
@[to_additive (attr := simp)
/-- The additive torsion submonoid of an additive torsion monoid is `⊤`. -/]
torsion_eq_top (tG : IsTorsion G) : torsion G = ⊤ := by ext; tauto | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsion_eq_top | The torsion submonoid of a torsion monoid is `⊤`. |
@[to_additive /-- An additive torsion monoid is isomorphic to its torsion submonoid. -/]
torsionMulEquiv (tG : IsTorsion G) : torsion G ≃* G :=
(MulEquiv.submonoidCongr tG.torsion_eq_top).trans Submonoid.topEquiv
@[to_additive] | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsionMulEquiv | A torsion monoid is isomorphic to its torsion submonoid. |
torsionMulEquiv_apply (tG : IsTorsion G) (a : torsion G) :
tG.torsionMulEquiv a = MulEquiv.submonoidCongr tG.torsion_eq_top a :=
rfl
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsionMulEquiv_apply | null |
torsionMulEquiv_symm_apply_coe (tG : IsTorsion G) (a : G) :
tG.torsionMulEquiv.symm a = ⟨Submonoid.topEquiv.symm a, tG _⟩ :=
rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsionMulEquiv_symm_apply_coe | null |
@[to_additive (attr := simp) AddCommMonoid.Torsion.ofTorsion
/-- Additive torsion submonoids of an additive torsion submonoid are
isomorphic to the submonoid. -/]
Torsion.ofTorsion : torsion (torsion G) ≃* torsion G :=
Monoid.IsTorsion.torsionMulEquiv CommMonoid.torsion.isTorsion | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | Torsion.ofTorsion | Torsion submonoids of a torsion submonoid are isomorphic to the submonoid. |
@[to_additive /-- The torsion subgroup of an additive abelian group. -/]
torsion : Subgroup G :=
{ CommMonoid.torsion G with inv_mem' := fun hx => IsOfFinOrder.inv hx } | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsion | The torsion subgroup of an abelian group. |
@[to_additive add_torsion_eq_add_torsion_submonoid
/-- The additive torsion submonoid of an abelian group equals the torsion
subgroup as a submonoid. -/]
torsion_eq_torsion_submonoid : CommMonoid.torsion G = (torsion G).toSubmonoid :=
rfl
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | torsion_eq_torsion_submonoid | The torsion submonoid of an abelian group equals the torsion subgroup as a submonoid. |
mem_torsion (g : G) : g ∈ torsion G ↔ IsOfFinOrder g := Iff.rfl
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | mem_torsion | null |
isMulTorsionFree_iff_torsion_eq_bot : IsMulTorsionFree G ↔ CommGroup.torsion G = ⊥ := by
rw [isMulTorsionFree_iff_not_isOfFinOrder, eq_bot_iff, SetLike.le_def]
simp [not_imp_not, CommGroup.mem_torsion]
variable (p : ℕ) [hp : Fact p.Prime] | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | isMulTorsionFree_iff_torsion_eq_bot | null |
@[to_additive (attr := simps!)
/-- The `p`-primary component is the subgroup of elements with additive order
prime-power of `p`. -/]
primaryComponent : Subgroup G :=
{ CommMonoid.primaryComponent G p with
inv_mem' := fun {g} ⟨n, hn⟩ => ⟨n, (orderOf_inv g).trans hn⟩ }
variable {G} {p} | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | primaryComponent | The `p`-primary component is the subgroup of elements with order prime-power of `p`. |
primaryComponent.isPGroup : IsPGroup p <| primaryComponent G p := fun g =>
(propext exists_orderOf_eq_prime_pow_iff.symm).mpr
(CommMonoid.primaryComponent.exists_orderOf_eq_prime_pow g) | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | primaryComponent.isPGroup | The `p`-primary component is a `p` group. |
@[to_additive /-- A predicate on an additive monoid saying that only 0 is of finite order.
This definition is mathematically incorrect for monoids which are not groups.
Please use `IsAddTorsionFree` instead. -/]
IsTorsionFree :=
∀ g : G, g ≠ 1 → ¬IsOfFinOrder g
attribute [deprecated IsMulTorsionFree (since := "2025-04-23")] Monoid.IsTorsionFree
attribute [deprecated IsAddTorsionFree (since := "2025-04-23")] AddMonoid.IsTorsionFree
variable {G}
set_option linter.deprecated false in | def | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsionFree | A predicate on a monoid saying that only 1 is of finite order.
This definition is mathematically incorrect for monoids which are not groups.
Please use `IsMulTorsionFree` instead. |
@[to_additive (attr := deprecated not_isMulTorsionFree_iff_isOfFinOrder (since := "2025-04-23"))
/-- An additive monoid is not torsion free if any nontrivial element has finite order. -/]
not_isTorsionFree_iff : ¬IsTorsionFree G ↔ ∃ g : G, g ≠ 1 ∧ IsOfFinOrder g := by
simp_rw [IsTorsionFree, Ne, not_forall, Classical.not_not, exists_prop]
set_option linter.deprecated false in
@[to_additive (attr := deprecated Subsingleton.to_isMulTorsionFree (since := "2025-04-23"))] | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | not_isTorsionFree_iff | A nontrivial monoid is not torsion-free if any nontrivial element has finite order. |
isTorsionFree_of_subsingleton [Subsingleton G] : IsTorsionFree G :=
fun _a ha _ => ha <| Subsingleton.elim _ _
set_option linter.deprecated false in
@[to_additive
(attr := deprecated CommGroup.isMulTorsionFree_iff_torsion_eq_bot (since := "2025-04-23"))] | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | isTorsionFree_of_subsingleton | null |
isTorsionFree_iff_torsion_eq_bot {G} [CommGroup G] :
IsTorsionFree G ↔ CommGroup.torsion G = ⊥ := by
rw [IsTorsionFree, eq_bot_iff, SetLike.le_def]
simp [not_imp_not, CommGroup.mem_torsion] | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | isTorsionFree_iff_torsion_eq_bot | null |
@[to_additive (attr := deprecated not_isMulTorsionFree_of_isTorsion (since := "2025-04-23"))
/-- A nontrivial additive torsion group is not torsion-free. -/]
IsTorsion.not_torsion_free [hN : Nontrivial G] : IsTorsion G → ¬IsTorsionFree G := fun tG =>
not_isTorsionFree_iff.mpr <| by
obtain ⟨x, hx⟩ := (nontrivial_iff_exists_ne (1 : G)).mp hN
exact ⟨x, hx, tG x⟩
set_option linter.deprecated false in | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsion.not_torsion_free | A nontrivial torsion group is not torsion-free. |
@[to_additive (attr := deprecated not_isTorsion_of_isMulTorsionFree (since := "2025-04-23"))
/-- A nontrivial torsion-free additive group is not torsion. -/]
IsTorsionFree.not_torsion [hN : Nontrivial G] : IsTorsionFree G → ¬IsTorsion G := fun tfG =>
(not_isTorsion_iff _).mpr <| by
obtain ⟨x, hx⟩ := (nontrivial_iff_exists_ne (1 : G)).mp hN
exact ⟨x, (tfG x) hx⟩
set_option linter.deprecated false in | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsionFree.not_torsion | A nontrivial torsion-free group is not torsion. |
@[to_additive (attr := deprecated Subgroup.instIsMulTorsionFree (since := "2025-04-23"))
/-- Subgroups of additive torsion-free groups are additively torsion-free. -/]
IsTorsionFree.subgroup (tG : IsTorsionFree G) (H : Subgroup G) : IsTorsionFree H :=
fun h hne ↦ Submonoid.isOfFinOrder_coe.not.1 <| tG h <| by norm_cast
set_option linter.deprecated false in | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsionFree.subgroup | Subgroups of torsion-free groups are torsion-free. |
@[to_additive (attr := deprecated Pi.instIsMulTorsionFree (since := "2025-04-23"))
AddMonoid.IsTorsionFree.prod
/-- Direct products of additive torsion free groups are torsion free. -/]
IsTorsionFree.prod {η : Type*} {Gs : η → Type*} [∀ i, Group (Gs i)]
(tfGs : ∀ i, IsTorsionFree (Gs i)) : IsTorsionFree <| ∀ i, Gs i := fun w hne h =>
hne <|
funext fun i => Classical.not_not.mp <| mt (tfGs i (w i)) <| Classical.not_not.mpr <| h.apply i | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsionFree.prod | Direct products of torsion free groups are torsion free. |
@[to_additive
/-- Quotienting a group by its additive torsion subgroup yields an additive torsion-free group. -/]
_root_.QuotientGroup.instIsMulTorsionFree : IsMulTorsionFree <| G ⧸ torsion G := by
refine .of_not_isOfFinOrder fun g hne hfin ↦ hne ?_
obtain ⟨g⟩ := g
obtain ⟨m, mpos, hm⟩ := hfin.exists_pow_eq_one
obtain ⟨n, npos, hn⟩ := ((QuotientGroup.eq_one_iff _).mp hm).exists_pow_eq_one
exact (QuotientGroup.eq_one_iff g).mpr
(isOfFinOrder_iff_pow_eq_one.mpr ⟨m * n, mul_pos mpos npos, (pow_mul g m n).symm ▸ hn⟩)
set_option linter.deprecated false in | instance | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | _root_.QuotientGroup.instIsMulTorsionFree | Quotienting a group by its torsion subgroup yields a torsion-free group. |
@[to_additive
(attr := deprecated QuotientGroup.instIsMulTorsionFree (since := "2025-04-23"))
/-- Quotienting a group by its additive torsion subgroup yields an additive torsion free group. -/]
IsTorsionFree.quotient_torsion : IsTorsionFree <| G ⧸ torsion G := fun g hne hfin =>
hne <| by
obtain ⟨g⟩ := g
obtain ⟨m, mpos, hm⟩ := hfin.exists_pow_eq_one
obtain ⟨n, npos, hn⟩ := ((QuotientGroup.eq_one_iff _).mp hm).exists_pow_eq_one
exact
(QuotientGroup.eq_one_iff g).mpr
(isOfFinOrder_iff_pow_eq_one.mpr ⟨m * n, mul_pos mpos npos, (pow_mul g m n).symm ▸ hn⟩) | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsionFree.quotient_torsion | Quotienting a group by its torsion subgroup yields a torsion free group. |
@[deprecated noZeroSMulDivisors_nat_iff_isAddTorsionFree (since := "2025-04-23")]
isTorsionFree_iff_noZeroSMulDivisors_nat {M : Type*} [AddMonoid M] :
IsTorsionFree M ↔ NoZeroSMulDivisors ℕ M := by
simp_rw [AddMonoid.IsTorsionFree, isOfFinAddOrder_iff_nsmul_eq_zero, not_exists, not_and,
pos_iff_ne_zero, noZeroSMulDivisors_iff, forall_swap (β := ℕ)]
exact forall₂_congr fun _ _ ↦ by tauto
set_option linter.deprecated false in
@[deprecated noZeroSMulDivisors_int_iff_isAddTorsionFree (since := "2025-04-23")] | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | isTorsionFree_iff_noZeroSMulDivisors_nat | null |
isTorsionFree_iff_noZeroSMulDivisors_int [SubtractionMonoid G] :
IsTorsionFree G ↔ NoZeroSMulDivisors ℤ G := by
simp_rw [AddMonoid.IsTorsionFree, isOfFinAddOrder_iff_zsmul_eq_zero, not_exists, not_and,
noZeroSMulDivisors_iff, forall_swap (β := ℤ)]
exact forall₂_congr fun _ _ ↦ by tauto
set_option linter.deprecated false in
@[deprecated IsAddTorsionFree.of_noZeroSMulDivisors_nat (since := "2025-04-23")] | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | isTorsionFree_iff_noZeroSMulDivisors_int | null |
IsTorsionFree.of_noZeroSMulDivisors {M : Type*} [AddMonoid M] [NoZeroSMulDivisors ℕ M] :
IsTorsionFree M := isTorsionFree_iff_noZeroSMulDivisors_nat.2 ‹_›
@[deprecated IsAddTorsionFree.to_noZeroSMulDivisors_nat (since := "2025-04-23")]
alias ⟨IsTorsionFree.noZeroSMulDivisors_nat, _⟩ := isTorsionFree_iff_noZeroSMulDivisors_nat
@[deprecated IsAddTorsionFree.to_noZeroSMulDivisors_int (since := "2025-04-23")]
alias ⟨IsTorsionFree.noZeroSMulDivisors_int, _⟩ := isTorsionFree_iff_noZeroSMulDivisors_int | lemma | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | IsTorsionFree.of_noZeroSMulDivisors | null |
neg_one_mem_torsion : -1 ∈ CommMonoid.torsion M :=
⟨2, zero_lt_two, (isPeriodicPt_mul_iff_pow_eq_one _).mpr (by simp)⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.PGroup",
"Mathlib.LinearAlgebra.Quotient.Defs"
] | Mathlib/GroupTheory/Torsion.lean | neg_one_mem_torsion | null |
@[to_additive /-- The difference of two left transversals -/]
noncomputable diff : A :=
let α := S.2.leftQuotientEquiv
let β := T.2.leftQuotientEquiv
let _ := H.fintypeQuotientOfFiniteIndex
∏ q : G ⧸ H, ϕ
⟨(α q : G)⁻¹ * β q,
QuotientGroup.leftRel_apply.mp <|
Quotient.exact' ((α.symm_apply_apply q).trans (β.symm_apply_apply q).symm)⟩
@[to_additive] | def | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | diff | The difference of two left transversals |
diff_mul_diff : diff ϕ R S * diff ϕ S T = diff ϕ R T :=
prod_mul_distrib.symm.trans
(prod_congr rfl fun q _ =>
(ϕ.map_mul _ _).symm.trans
(congr_arg ϕ
(by simp_rw [Subtype.ext_iff, coe_mul, mul_assoc, mul_inv_cancel_left])))
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | diff_mul_diff | null |
diff_self : diff ϕ T T = 1 :=
mul_eq_left.mp (diff_mul_diff ϕ T T T)
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | diff_self | null |
diff_inv : (diff ϕ S T)⁻¹ = diff ϕ T S :=
inv_eq_of_mul_eq_one_right <| (diff_mul_diff ϕ S T S).trans <| diff_self ϕ S
@[to_additive] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | diff_inv | null |
smul_diff_smul (g : G) : diff ϕ (g • S) (g • T) = diff ϕ S T :=
let _ := H.fintypeQuotientOfFiniteIndex
Fintype.prod_equiv (MulAction.toPerm g).symm _ _ fun _ ↦ by
simp only [smul_apply_eq_smul_apply_inv_smul, smul_eq_mul, mul_inv_rev, mul_assoc,
inv_mul_cancel_left, toPerm_symm_apply] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | smul_diff_smul | null |
noncomputable transferFunction : G ⧸ H → G := fun q =>
g ^ (cast (quotientEquivSigmaZMod H g q).2 : ℤ) * (quotientEquivSigmaZMod H g q).1.out.out | def | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | transferFunction | The transfer transversal as a function. Given a `⟨g⟩`-orbit `q₀, g • q₀, ..., g ^ (m - 1) • q₀`
in `G ⧸ H`, an element `g ^ k • q₀` is mapped to `g ^ k • g₀` for a fixed choice of
representative `g₀` of `q₀`. |
transferFunction_apply (q : G ⧸ H) :
transferFunction H g q =
g ^ (cast (quotientEquivSigmaZMod H g q).2 : ℤ) *
(quotientEquivSigmaZMod H g q).1.out.out := rfl | lemma | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | transferFunction_apply | null |
coe_transferFunction (q : G ⧸ H) : ↑(transferFunction H g q) = q := by
rw [transferFunction_apply, ← smul_eq_mul, Quotient.coe_smul_out,
← quotientEquivSigmaZMod_symm_apply, Sigma.eta, symm_apply_apply]
variable (H) in | lemma | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | coe_transferFunction | null |
transferSet : Set G := Set.range (transferFunction H g) | def | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | transferSet | The transfer transversal as a set. Contains elements of the form `g ^ k • g₀` for fixed choices
of representatives `g₀` of fixed choices of representatives `q₀` of `⟨g⟩`-orbits in `G ⧸ H`. |
mem_transferSet (q : G ⧸ H) : transferFunction H g q ∈ transferSet H g := ⟨q, rfl⟩
variable (H) in | lemma | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | mem_transferSet | null |
transferTransversal : H.LeftTransversal :=
⟨transferSet H g, isComplement_range_left (coe_transferFunction g)⟩ | def | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | transferTransversal | The transfer transversal. Contains elements of the form `g ^ k • g₀` for fixed choices
of representatives `g₀` of fixed choices of representatives `q₀` of `⟨g⟩`-orbits in `G ⧸ H`. |
transferTransversal_apply (q : G ⧸ H) :
↑((transferTransversal H g).2.leftQuotientEquiv q) = transferFunction H g q :=
IsComplement.leftQuotientEquiv_apply (coe_transferFunction g) q | lemma | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | transferTransversal_apply | null |
transferTransversal_apply' (q : orbitRel.Quotient (zpowers g) (G ⧸ H))
(k : ZMod (minimalPeriod (g • ·) q.out)) :
↑((transferTransversal H g).2.leftQuotientEquiv (g ^ (cast k : ℤ) • q.out)) =
g ^ (cast k : ℤ) * q.out.out := by
rw [transferTransversal_apply, transferFunction_apply, ← quotientEquivSigmaZMod_symm_apply,
apply_symm_apply] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Complement",
"Mathlib.GroupTheory.Sylow"
] | Mathlib/GroupTheory/Transfer.lean | transferTransversal_apply' | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.