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 ⌀ |
|---|---|---|---|---|---|---|
of_bot : IsPGroup p (⊥ : Subgroup G) :=
of_card (n := 0) (by rw [Subgroup.card_bot, pow_zero]) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | of_bot | null |
iff_card [Fact p.Prime] [Finite G] : IsPGroup p G ↔ ∃ n : ℕ, Nat.card G = p ^ n := by
have hG : Nat.card G ≠ 0 := Nat.card_pos.ne'
refine ⟨fun h => ?_, fun ⟨n, hn⟩ => of_card hn⟩
suffices ∀ q ∈ (Nat.card G).primeFactorsList, q = p by
use (Nat.card G).primeFactorsList.length
rw [← List.prod_replicate, ← Li... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | iff_card | null |
of_injective {H : Type*} [Group H] (ϕ : H →* G) (hϕ : Function.Injective ϕ) :
IsPGroup p H := by
simp_rw [IsPGroup, ← hϕ.eq_iff, ϕ.map_pow, ϕ.map_one]
exact fun h => hG (ϕ h) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | of_injective | null |
to_subgroup (H : Subgroup G) : IsPGroup p H :=
hG.of_injective H.subtype Subtype.coe_injective | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_subgroup | null |
of_surjective {H : Type*} [Group H] (ϕ : G →* H) (hϕ : Function.Surjective ϕ) :
IsPGroup p H := by
refine fun h => Exists.elim (hϕ h) fun g hg => Exists.imp (fun k hk => ?_) (hG g)
rw [← hg, ← ϕ.map_pow, hk, ϕ.map_one] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | of_surjective | null |
to_quotient (H : Subgroup G) [H.Normal] : IsPGroup p (G ⧸ H) :=
hG.of_surjective (QuotientGroup.mk' H) Quotient.mk''_surjective | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_quotient | null |
of_equiv {H : Type*} [Group H] (ϕ : G ≃* H) : IsPGroup p H :=
hG.of_surjective ϕ.toMonoidHom ϕ.surjective | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | of_equiv | null |
orderOf_coprime {n : ℕ} (hn : p.Coprime n) (g : G) : (orderOf g).Coprime n :=
let ⟨k, hk⟩ := hG g
(hn.pow_left k).coprime_dvd_left (orderOf_dvd_of_pow_eq_one hk) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | orderOf_coprime | null |
noncomputable powEquiv {n : ℕ} (hn : p.Coprime n) : G ≃ G :=
let h : ∀ g : G, (Nat.card (Subgroup.zpowers g)).Coprime n := fun g =>
(Nat.card_zpowers g).symm ▸ hG.orderOf_coprime hn g
{ toFun := (· ^ n)
invFun := fun g => (powCoprime (h g)).symm ⟨g, Subgroup.mem_zpowers g⟩
left_inv := fun g =>
Sub... | def | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | powEquiv | If `gcd(p,n) = 1`, then the `n`th power map is a bijection. |
powEquiv_apply {n : ℕ} (hn : p.Coprime n) (g : G) : hG.powEquiv hn g = g ^ n :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | powEquiv_apply | null |
powEquiv_symm_apply {n : ℕ} (hn : p.Coprime n) (g : G) :
(hG.powEquiv hn).symm g = g ^ (orderOf g).gcdB n := by rw [← Nat.card_zpowers]; rfl
variable [hp : Fact p.Prime] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | powEquiv_symm_apply | null |
noncomputable powEquiv' {n : ℕ} (hn : ¬p ∣ n) : G ≃ G :=
powEquiv hG (hp.out.coprime_iff_not_dvd.mpr hn) | abbrev | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | powEquiv' | If `p ∤ n`, then the `n`th power map is a bijection. |
index (H : Subgroup G) [H.FiniteIndex] : ∃ n : ℕ, H.index = p ^ n := by
obtain ⟨n, hn⟩ := iff_card.mp (hG.to_quotient H.normalCore)
obtain ⟨k, _, hk2⟩ :=
(Nat.dvd_prime_pow hp.out).mp
((congr_arg _ (H.normalCore.index_eq_card.trans hn)).mp
(Subgroup.index_dvd_of_le H.normalCore_le))
exact ⟨k, hk... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | index | null |
card_eq_or_dvd : Nat.card G = 1 ∨ p ∣ Nat.card G := by
cases finite_or_infinite G
· obtain ⟨n, hn⟩ := iff_card.mp hG
rw [hn]
rcases n with - | n
· exact Or.inl rfl
· exact Or.inr ⟨p ^ n, by rw [pow_succ']⟩
· rw [Nat.card_eq_zero_of_infinite]
exact Or.inr ⟨0, rfl⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | card_eq_or_dvd | null |
nontrivial_iff_card [Finite G] : Nontrivial G ↔ ∃ n > 0, Nat.card G = p ^ n :=
⟨fun hGnt =>
let ⟨k, hk⟩ := iff_card.1 hG
⟨k,
Nat.pos_of_ne_zero fun hk0 => by
rw [hk0, pow_zero] at hk; exact Finite.one_lt_card.ne' hk,
hk⟩,
fun ⟨_, hk0, hk⟩ =>
Finite.one_lt_card_iff_nontrivial.1 <|
... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | nontrivial_iff_card | null |
card_orbit (a : α) [Finite (orbit G a)] : ∃ n : ℕ, Nat.card (orbit G a) = p ^ n := by
let ϕ := orbitEquivQuotientStabilizer G a
haveI := Finite.of_equiv (orbit G a) ϕ
haveI := (stabilizer G a).finiteIndex_of_finite_quotient
rw [Nat.card_congr ϕ]
exact hG.index (stabilizer G a)
variable (α) [Finite α] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | card_orbit | null |
card_modEq_card_fixedPoints : Nat.card α ≡ Nat.card (fixedPoints G α) [MOD p] := by
have := Fintype.ofFinite α
have := Fintype.ofFinite (fixedPoints G α)
rw [Nat.card_eq_fintype_card, Nat.card_eq_fintype_card]
classical
calc
card α = card (Σ y : Quotient (orbitRel G α), { x // Quotient.mk'' x = y }) :... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | card_modEq_card_fixedPoints | If `G` is a `p`-group acting on a finite set `α`, then the number of fixed points
of the action is congruent mod `p` to the cardinality of `α` |
nonempty_fixed_point_of_prime_not_dvd_card (α) [MulAction G α] (hpα : ¬p ∣ Nat.card α) :
(fixedPoints G α).Nonempty :=
have : Finite α := Nat.finite_of_card_ne_zero (fun h ↦ (h ▸ hpα) (dvd_zero p))
@Set.Nonempty.of_subtype _ _
(by
rw [← Finite.card_pos_iff, pos_iff_ne_zero]
contrapose! hpα
... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | nonempty_fixed_point_of_prime_not_dvd_card | If a p-group acts on `α` and the cardinality of `α` is not a multiple
of `p` then the action has a fixed point. |
exists_fixed_point_of_prime_dvd_card_of_fixed_point (hpα : p ∣ Nat.card α) {a : α}
(ha : a ∈ fixedPoints G α) : ∃ b, b ∈ fixedPoints G α ∧ a ≠ b := by
have hpf : p ∣ Nat.card (fixedPoints G α) :=
Nat.modEq_zero_iff_dvd.mp ((hG.card_modEq_card_fixedPoints α).symm.trans hpα.modEq_zero_nat)
have hα : 1 < Nat.c... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | exists_fixed_point_of_prime_dvd_card_of_fixed_point | If a p-group acts on `α` and the cardinality of `α` is a multiple
of `p`, and the action has one fixed point, then it has another fixed point. |
center_nontrivial [Nontrivial G] [Finite G] : Nontrivial (Subgroup.center G) := by
classical
have := (hG.of_equiv ConjAct.toConjAct).exists_fixed_point_of_prime_dvd_card_of_fixed_point G
rw [ConjAct.fixedPoints_eq_center] at this
have dvd : p ∣ Nat.card G := by
obtain ⟨n, hn0, hn⟩ := hG.nontrivial_i... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | center_nontrivial | null |
bot_lt_center [Nontrivial G] [Finite G] : ⊥ < Subgroup.center G := by
haveI := center_nontrivial hG
classical exact
bot_lt_iff_ne_bot.mpr ((Subgroup.center G).one_lt_card_iff_ne_bot.mp Finite.one_lt_card) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | bot_lt_center | null |
to_le {H K : Subgroup G} (hK : IsPGroup p K) (hHK : H ≤ K) : IsPGroup p H :=
hK.of_injective (Subgroup.inclusion hHK) fun a b h =>
Subtype.ext (by
change ((Subgroup.inclusion hHK) a : G) = (Subgroup.inclusion hHK) b
apply Subtype.ext_iff.mp h) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_le | null |
to_inf_left {H K : Subgroup G} (hH : IsPGroup p H) : IsPGroup p (H ⊓ K : Subgroup G) :=
hH.to_le inf_le_left | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_inf_left | null |
to_inf_right {H K : Subgroup G} (hK : IsPGroup p K) : IsPGroup p (H ⊓ K : Subgroup G) :=
hK.to_le inf_le_right | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_inf_right | null |
map {H : Subgroup G} (hH : IsPGroup p H) {K : Type*} [Group K] (ϕ : G →* K) :
IsPGroup p (H.map ϕ) := by
rw [← H.range_subtype, MonoidHom.map_range]
exact hH.of_surjective (ϕ.restrict H).rangeRestrict (ϕ.restrict H).rangeRestrict_surjective | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | map | null |
comap_of_ker_isPGroup {H : Subgroup G} (hH : IsPGroup p H) {K : Type*} [Group K]
(ϕ : K →* G) (hϕ : IsPGroup p ϕ.ker) : IsPGroup p (H.comap ϕ) := by
intro g
obtain ⟨j, hj⟩ := hH ⟨ϕ g.1, g.2⟩
rw [Subtype.ext_iff, H.coe_pow, Subtype.coe_mk, ← ϕ.map_pow] at hj
obtain ⟨k, hk⟩ := hϕ ⟨g.1 ^ p ^ j, hj⟩
rw [Subty... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | comap_of_ker_isPGroup | null |
ker_isPGroup_of_injective {K : Type*} [Group K] {ϕ : K →* G} (hϕ : Function.Injective ϕ) :
IsPGroup p ϕ.ker :=
(congr_arg (fun Q : Subgroup K => IsPGroup p Q) (ϕ.ker_eq_bot_iff.mpr hϕ)).mpr IsPGroup.of_bot | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | ker_isPGroup_of_injective | null |
comap_of_injective {H : Subgroup G} (hH : IsPGroup p H) {K : Type*} [Group K] (ϕ : K →* G)
(hϕ : Function.Injective ϕ) : IsPGroup p (H.comap ϕ) :=
hH.comap_of_ker_isPGroup ϕ (ker_isPGroup_of_injective hϕ) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | comap_of_injective | null |
comap_subtype {H : Subgroup G} (hH : IsPGroup p H) {K : Subgroup G} :
IsPGroup p (H.comap K.subtype) :=
hH.comap_of_injective K.subtype Subtype.coe_injective | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | comap_subtype | null |
to_sup_of_normal_right {H K : Subgroup G} (hH : IsPGroup p H) (hK : IsPGroup p K)
[K.Normal] : IsPGroup p (H ⊔ K : Subgroup G) := by
rw [← QuotientGroup.ker_mk' K, ← Subgroup.comap_map_eq]
apply (hH.map (QuotientGroup.mk' K)).comap_of_ker_isPGroup
rwa [QuotientGroup.ker_mk'] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_sup_of_normal_right | null |
to_sup_of_normal_left {H K : Subgroup G} (hH : IsPGroup p H) (hK : IsPGroup p K)
[H.Normal] : IsPGroup p (H ⊔ K : Subgroup G) := sup_comm H K ▸ to_sup_of_normal_right hK hH | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_sup_of_normal_left | null |
to_sup_of_normal_right' {H K : Subgroup G} (hH : IsPGroup p H) (hK : IsPGroup p K)
(hHK : H ≤ K.normalizer) : IsPGroup p (H ⊔ K : Subgroup G) :=
let hHK' :=
to_sup_of_normal_right (hH.of_equiv (Subgroup.subgroupOfEquivOfLe hHK).symm)
(hK.of_equiv (Subgroup.subgroupOfEquivOfLe Subgroup.le_normalizer).sym... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_sup_of_normal_right' | null |
to_sup_of_normal_left' {H K : Subgroup G} (hH : IsPGroup p H) (hK : IsPGroup p K)
(hHK : K ≤ H.normalizer) : IsPGroup p (H ⊔ K : Subgroup G) :=
sup_comm H K ▸ to_sup_of_normal_right' hK hH hHK | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | to_sup_of_normal_left' | null |
coprime_card_of_ne {G₂ : Type*} [Group G₂] (p₁ p₂ : ℕ) [hp₁ : Fact p₁.Prime]
[hp₂ : Fact p₂.Prime] (hne : p₁ ≠ p₂) (H₁ : Subgroup G) (H₂ : Subgroup G₂) [Finite H₁]
[Finite H₂] (hH₁ : IsPGroup p₁ H₁) (hH₂ : IsPGroup p₂ H₂) :
Nat.Coprime (Nat.card H₁) (Nat.card H₂) := by
obtain ⟨n₁, heq₁⟩ := iff_card.mp hH₁... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | coprime_card_of_ne | finite p-groups with different p have coprime orders |
disjoint_of_ne (p₁ p₂ : ℕ) [hp₁ : Fact p₁.Prime] [hp₂ : Fact p₂.Prime] (hne : p₁ ≠ p₂)
(H₁ H₂ : Subgroup G) (hH₁ : IsPGroup p₁ H₁) (hH₂ : IsPGroup p₂ H₂) : Disjoint H₁ H₂ := by
rw [Subgroup.disjoint_def]
intro x hx₁ hx₂
obtain ⟨n₁, hn₁⟩ := iff_orderOf.mp hH₁ ⟨x, hx₁⟩
obtain ⟨n₂, hn₂⟩ := iff_orderOf.mp hH₂ ⟨... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | disjoint_of_ne | p-groups with different p are disjoint |
le_or_disjoint_of_coprime [hp : Fact p.Prime] {P : Subgroup G} (hP : IsPGroup p P)
{H : Subgroup G} [H.Normal] (h_cop : (Nat.card H).Coprime H.index) :
P ≤ H ∨ Disjoint H P := by
by_cases h1 : Nat.card H = 0
· rw [h1, Nat.coprime_zero_left, Subgroup.index_eq_one] at h_cop
rw [h_cop]
exact Or.inl le_... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | le_or_disjoint_of_coprime | null |
card_center_eq_prime_pow (hGpn : Nat.card G = p ^ n) (hn : 0 < n) :
∃ k > 0, Nat.card (center G) = p ^ k := by
have : Finite G := Nat.finite_of_card_ne_zero (hGpn ▸ pow_ne_zero n (NeZero.ne p))
have hcG := to_subgroup (of_card hGpn) (center G)
rcases iff_card.1 hcG with _
haveI : Nontrivial G := (nontrivial... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | card_center_eq_prime_pow | The cardinality of the `center` of a `p`-group is `p ^ k` where `k` is positive. |
cyclic_center_quotient_of_card_eq_prime_sq (hG : Nat.card G = p ^ 2) :
IsCyclic (G ⧸ center G) := by
apply isCyclic_of_card_dvd_prime (p := p)
rw [← mul_dvd_mul_iff_left (NeZero.ne p), ← sq, ← hG, ← (center G).card_mul_index]
apply mul_dvd_mul_right
rcases card_center_eq_prime_pow hG zero_lt_two with ⟨k, hk... | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | cyclic_center_quotient_of_card_eq_prime_sq | The quotient by the center of a group of cardinality `p ^ 2` is cyclic. |
commGroupOfCardEqPrimeSq (hG : Nat.card G = p ^ 2) : CommGroup G :=
@commGroupOfCyclicCenterQuotient _ _ _ _ (cyclic_center_quotient_of_card_eq_prime_sq hG) _
(QuotientGroup.ker_mk' (center G)).le | def | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | commGroupOfCardEqPrimeSq | A group of order `p ^ 2` is commutative. See also `IsPGroup.commutative_of_card_eq_prime_sq`
for just the proof that `∀ a b, a * b = b * a` |
commutative_of_card_eq_prime_sq (hG : Nat.card G = p ^ 2) : ∀ a b : G, a * b = b * a :=
(commGroupOfCardEqPrimeSq hG).mul_comm | theorem | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | commutative_of_card_eq_prime_sq | A group of order `p ^ 2` is commutative. See also `IsPGroup.commGroupOfCardEqPrimeSq`
for the `CommGroup` instance. |
isPGroup_multiplicative : IsPGroup n (Multiplicative G) := by
simpa [IsPGroup, Multiplicative.forall] using
fun _ ↦ ⟨1, by simp [← ofAdd_nsmul, ZModModule.char_nsmul_eq_zero]⟩ | lemma | GroupTheory | [
"Mathlib.GroupTheory.Perm.Cycle.Type",
"Mathlib.GroupTheory.SpecificGroups.Cyclic"
] | Mathlib/GroupTheory/PGroup.lean | isPGroup_multiplicative | null |
PresentedGroup (rels : Set (FreeGroup α)) :=
FreeGroup α ⧸ Subgroup.normalClosure rels | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | PresentedGroup | Given a set of relations, `rels`, over a type `α`, `PresentedGroup` constructs the group with
generators `x : α` and relations `rels` as a quotient of `FreeGroup α`. |
mk (rels : Set (FreeGroup α)) : FreeGroup α →* PresentedGroup rels :=
⟨⟨QuotientGroup.mk, rfl⟩, fun _ _ => rfl⟩ | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | mk | The canonical map from the free group on `α` to a presented group with generators `x : α`,
where `x` is mapped to its equivalence class under the given set of relations `rels` |
mk_surjective (rels : Set (FreeGroup α)) : Function.Surjective <| mk rels :=
QuotientGroup.mk_surjective | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | mk_surjective | null |
of {rels : Set (FreeGroup α)} (x : α) : PresentedGroup rels :=
mk rels (FreeGroup.of x) | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | of | `of` is the canonical map from `α` to a presented group with generators `x : α`. The term `x` is
mapped to the equivalence class of the image of `x` in `FreeGroup α`. |
mk_eq_one_iff {rels : Set (FreeGroup α)} {x : FreeGroup α} :
mk rels x = 1 ↔ x ∈ Subgroup.normalClosure rels :=
QuotientGroup.eq_one_iff _ | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | mk_eq_one_iff | null |
one_of_mem {rels : Set (FreeGroup α)} {x : FreeGroup α} (hx : x ∈ rels) :
mk rels x = 1 :=
mk_eq_one_iff.mpr <| Subgroup.subset_normalClosure hx | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | one_of_mem | null |
mk_eq_mk_of_mul_inv_mem {rels : Set (FreeGroup α)} {x y : FreeGroup α}
(hx : x * y⁻¹ ∈ rels) : mk rels x = mk rels y :=
eq_of_mul_inv_eq_one <| one_of_mem hx | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | mk_eq_mk_of_mul_inv_mem | null |
mk_eq_mk_of_inv_mul_mem {rels : Set (FreeGroup α)} {x y : FreeGroup α}
(hx : x⁻¹ * y ∈ rels) : mk rels x = mk rels y :=
eq_of_inv_mul_eq_one <| one_of_mem hx | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | mk_eq_mk_of_inv_mul_mem | null |
@[simp]
closure_range_of (rels : Set (FreeGroup α)) :
Subgroup.closure (Set.range (PresentedGroup.of : α → PresentedGroup rels)) = ⊤ := by
have : (PresentedGroup.of : α → PresentedGroup rels) = QuotientGroup.mk' _ ∘ FreeGroup.of := rfl
rw [this, Set.range_comp, ← MonoidHom.map_closure (QuotientGroup.mk' _),
... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | closure_range_of | The generators of a presented group generate the presented group. That is, the subgroup closure
of the set of generators equals `⊤`. |
induction_on {rels : Set (FreeGroup α)} {C : PresentedGroup rels → Prop}
(x : PresentedGroup rels) (H : ∀ z, C (mk rels z)) : C x :=
Quotient.inductionOn' x H | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | induction_on | null |
generated_by (rels : Set (FreeGroup α)) (H : Subgroup (PresentedGroup rels))
(h : ∀ j : α, PresentedGroup.of j ∈ H) (x : PresentedGroup rels) : x ∈ H := by
obtain ⟨z⟩ := x
induction z
· exact one_mem H
· exact h _
· exact (Subgroup.inv_mem_iff H).mpr (by assumption)
rename_i h1 h2
change QuotientGroup... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | generated_by | null |
closure_rels_subset_ker (h : ∀ r ∈ rels, FreeGroup.lift f r = 1) :
Subgroup.normalClosure rels ≤ MonoidHom.ker F :=
Subgroup.normalClosure_le_normal fun x w ↦ MonoidHom.mem_ker.2 (h x w) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | closure_rels_subset_ker | null |
to_group_eq_one_of_mem_closure (h : ∀ r ∈ rels, FreeGroup.lift f r = 1) :
∀ x ∈ Subgroup.normalClosure rels, F x = 1 :=
fun _ w ↦ MonoidHom.mem_ker.1 <| closure_rels_subset_ker h w | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | to_group_eq_one_of_mem_closure | null |
toGroup (h : ∀ r ∈ rels, FreeGroup.lift f r = 1) : PresentedGroup rels →* G :=
QuotientGroup.lift (Subgroup.normalClosure rels) F (to_group_eq_one_of_mem_closure h)
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | toGroup | The extension of a map `f : α → G` that satisfies the given relations to a group homomorphism
from `PresentedGroup rels → G`. |
toGroup.of (h : ∀ r ∈ rels, FreeGroup.lift f r = 1) {x : α} : toGroup h (of x) = f x :=
FreeGroup.lift_apply_of | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | toGroup.of | null |
toGroup.unique (h : ∀ r ∈ rels, FreeGroup.lift f r = 1) (g : PresentedGroup rels →* G)
(hg : ∀ x : α, g (PresentedGroup.of x) = f x) : ∀ {x}, g x = toGroup h x := by
intro x
refine QuotientGroup.induction_on x ?_
exact fun _ ↦ FreeGroup.lift_unique (g.comp (QuotientGroup.mk' _)) hg
@[ext] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | toGroup.unique | null |
ext {φ ψ : PresentedGroup rels →* G} (hx : ∀ (x : α), φ (.of x) = ψ (.of x)) : φ = ψ := by
unfold PresentedGroup
ext
apply hx
variable {β : Type*} | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | ext | null |
equivPresentedGroup (rels : Set (FreeGroup α)) (e : α ≃ β) :
PresentedGroup rels ≃* PresentedGroup (FreeGroup.freeGroupCongr e '' rels) :=
QuotientGroup.congr (Subgroup.normalClosure rels)
(Subgroup.normalClosure ((FreeGroup.freeGroupCongr e) '' rels)) (FreeGroup.freeGroupCongr e)
(Subgroup.map_normalClos... | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | equivPresentedGroup | Presented groups of isomorphic types are isomorphic. |
equivPresentedGroup_apply_of (x : α) (rels : Set (FreeGroup α)) (e : α ≃ β) :
equivPresentedGroup rels e (PresentedGroup.of x) =
PresentedGroup.of (rels := FreeGroup.freeGroupCongr e '' rels) (e x) := rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | equivPresentedGroup_apply_of | null |
equivPresentedGroup_symm_apply_of (x : β) (rels : Set (FreeGroup α)) (e : α ≃ β) :
(equivPresentedGroup rels e).symm (PresentedGroup.of x) =
PresentedGroup.of (rels := rels) (e.symm x) := rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Basic",
"Mathlib.GroupTheory.FreeGroup.Basic",
"Mathlib.GroupTheory.QuotientGroup.Defs"
] | Mathlib/GroupTheory/PresentedGroup.lean | equivPresentedGroup_symm_apply_of | null |
PushoutI.con [∀ i, Monoid (G i)] [Monoid H] (φ : ∀ i, H →* G i) :
Con (Coprod (CoprodI G) H) :=
conGen (fun x y : Coprod (CoprodI G) H =>
∃ i x', x = inl (of (φ i x')) ∧ y = inr x') | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | PushoutI.con | The relation we quotient by to form the pushout |
PushoutI [∀ i, Monoid (G i)] [Monoid H] (φ : ∀ i, H →* G i) : Type _ :=
(PushoutI.con φ).Quotient | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | PushoutI | The indexed pushout of monoids, which is the pushout in the category of monoids,
or the category of groups. |
protected mul : Mul (PushoutI φ) := by
delta PushoutI; infer_instance | instance | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | mul | null |
protected one : One (PushoutI φ) := by
delta PushoutI; infer_instance | instance | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | one | null |
monoid : Monoid (PushoutI φ) :=
{ Con.monoid _ with
toMul := PushoutI.mul
toOne := PushoutI.one } | instance | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | monoid | null |
of (i : ι) : G i →* PushoutI φ :=
(Con.mk' _).comp <| inl.comp CoprodI.of
variable (φ) in | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | of | The map from each indexing group into the pushout |
base : H →* PushoutI φ :=
(Con.mk' _).comp inr | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | base | The map from the base monoid into the pushout |
of_comp_eq_base (i : ι) : (of i).comp (φ i) = (base φ) := by
ext x
apply (Con.eq _).2
refine ConGen.Rel.of _ _ ?_
simp only [MonoidHom.comp_apply]
exact ⟨_, _, rfl, rfl⟩
variable (φ) in | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | of_comp_eq_base | null |
of_apply_eq_base (i : ι) (x : H) : of i (φ i x) = base φ x := by
rw [← MonoidHom.comp_apply, of_comp_eq_base] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | of_apply_eq_base | null |
lift (f : ∀ i, G i →* K) (k : H →* K)
(hf : ∀ i, (f i).comp (φ i) = k) :
PushoutI φ →* K :=
Con.lift _ (Coprod.lift (CoprodI.lift f) k) <| by
apply Con.conGen_le fun x y => ?_
rintro ⟨i, x', rfl, rfl⟩
simp only [DFunLike.ext_iff, MonoidHom.coe_comp, comp_apply] at hf
simp [hf]
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | lift | Define a homomorphism out of the pushout of monoids be defining it on each object in the
diagram |
lift_of (f : ∀ i, G i →* K) (k : H →* K)
(hf : ∀ i, (f i).comp (φ i) = k)
{i : ι} (g : G i) : (lift f k hf) (of i g : PushoutI φ) = f i g := by
delta PushoutI lift of
simp only [MonoidHom.coe_comp, Con.coe_mk', comp_apply, Con.lift_coe,
lift_apply_inl, CoprodI.lift_of]
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | lift_of | null |
lift_base (f : ∀ i, G i →* K) (k : H →* K)
(hf : ∀ i, (f i).comp (φ i) = k)
(g : H) : (lift f k hf) (base φ g : PushoutI φ) = k g := by
delta PushoutI lift base
simp only [MonoidHom.coe_comp, Con.coe_mk', comp_apply, Con.lift_coe, lift_apply_inr]
@[ext 1199] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | lift_base | null |
hom_ext {f g : PushoutI φ →* K}
(h : ∀ i, f.comp (of i : G i →* _) = g.comp (of i : G i →* _))
(hbase : f.comp (base φ) = g.comp (base φ)) : f = g :=
(MonoidHom.cancel_right Con.mk'_surjective).mp <|
Coprod.hom_ext
(CoprodI.ext_hom _ _ h)
hbase
@[ext high] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | hom_ext | null |
hom_ext_nonempty [hn : Nonempty ι]
{f g : PushoutI φ →* K}
(h : ∀ i, f.comp (of i : G i →* _) = g.comp (of i : G i →* _)) : f = g :=
hom_ext h <| by
cases hn with
| intro i =>
ext
rw [← of_comp_eq_base i, ← MonoidHom.comp_assoc, h, MonoidHom.comp_assoc] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | hom_ext_nonempty | null |
@[simps]
homEquiv :
(PushoutI φ →* K) ≃ { f : (Π i, G i →* K) × (H →* K) // ∀ i, (f.1 i).comp (φ i) = f.2 } :=
{ toFun := fun f => ⟨(fun i => f.comp (of i), f.comp (base φ)),
fun i => by rw [MonoidHom.comp_assoc, of_comp_eq_base]⟩
invFun := fun f => lift f.1.1 f.1.2 f.2,
left_inv := fun _ => hom_ext... | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | homEquiv | The equivalence that is part of the universal property of the pushout. A hom out of
the pushout is just a morphism out of all groups in the pushout that satisfies a commutativity
condition. |
ofCoprodI : CoprodI G →* PushoutI φ :=
CoprodI.lift of
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | ofCoprodI | The map from the coproduct into the pushout |
ofCoprodI_of (i : ι) (g : G i) :
(ofCoprodI (CoprodI.of g) : PushoutI φ) = of i g := by
simp [ofCoprodI] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | ofCoprodI_of | null |
induction_on {motive : PushoutI φ → Prop}
(x : PushoutI φ)
(of : ∀ (i : ι) (g : G i), motive (of i g))
(base : ∀ h, motive (base φ h))
(mul : ∀ x y, motive x → motive y → motive (x * y)) : motive x := by
delta PushoutI PushoutI.of PushoutI.base at *
induction x using Con.induction_on with
| H x =>... | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | induction_on | null |
Transversal : Type _ where
/-- All maps in the diagram are injective -/
injective : ∀ i, Injective (φ i)
/-- The underlying set, containing exactly one element of each coset of the base group -/
set : ∀ i, Set (G i)
/-- The chosen element of the base group itself is the identity -/
one_mem : ∀ i, 1 ∈ set i
... | structure | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | Transversal | The data we need to pick a normal form for words in the pushout. We need to pick a
canonical element of each coset. We also need all the maps in the diagram to be injective |
transversal_nonempty (hφ : ∀ i, Injective (φ i)) : Nonempty (Transversal φ) := by
choose t ht using fun i => (φ i).range.exists_isComplement_right 1
apply Nonempty.intro
exact
{ injective := hφ
set := t
one_mem := fun i => (ht i).2
compl := fun i => (ht i).1 }
variable {φ} | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | transversal_nonempty | null |
_root_.Monoid.PushoutI.NormalWord (d : Transversal φ) extends CoprodI.Word G where
/-- Every `NormalWord` is the product of an element of the base group and a word made up
of letters each of which is in the transversal. `head` is that element of the base group. -/
head : H
/-- All letter in the word are in the ... | structure | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | _root_.Monoid.PushoutI.NormalWord | The normal form for words in the pushout. Every element of the pushout is the product of an
element of the base group and a word made up of letters each of which is in the transversal. |
Pair (d : Transversal φ) (i : ι) extends CoprodI.Word.Pair G i where
/-- All letters in the word are in the transversal. -/
normalized : ∀ i g, ⟨i, g⟩ ∈ tail.toList → g ∈ d.set i
variable {d : Transversal φ} | structure | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | Pair | A `Pair d i` is a word in the coproduct, `Coprod G`, the `tail`, and an element of the group `G i`,
the `head`. The first letter of the `tail` must not be an element of `G i`.
Note that the `head` may be `1` Every letter in the `tail` must be in the transversal given by `d`.
Similar to `Monoid.CoprodI.Pair` except ever... |
@[simps!]
empty : NormalWord d := ⟨CoprodI.Word.empty, 1, fun i g => by simp [CoprodI.Word.empty]⟩ | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | empty | The empty normalized word, representing the identity element of the group. |
@[ext]
ext {w₁ w₂ : NormalWord d} (hhead : w₁.head = w₂.head)
(hlist : w₁.toList = w₂.toList) : w₁ = w₂ := by
rcases w₁ with ⟨⟨_, _, _⟩, _, _⟩
rcases w₂ with ⟨⟨_, _, _⟩, _, _⟩
simp_all
open Subgroup.IsComplement | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | ext | null |
baseAction : MulAction H (NormalWord d) :=
{ smul := fun h w => { w with head := h * w.head },
one_smul := by simp [instHSMul]
mul_smul := by simp [instHSMul, mul_assoc] } | instance | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | baseAction | null |
base_smul_def' (h : H) (w : NormalWord d) :
h • w = { w with head := h * w.head } := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | base_smul_def' | null |
prod (w : NormalWord d) : PushoutI φ :=
base φ w.head * ofCoprodI (w.toWord).prod
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod | Take the product of a normal word as an element of the `PushoutI`. We show that this is
bijective, in `NormalWord.equiv`. |
prod_base_smul (h : H) (w : NormalWord d) :
(h • w).prod = base φ h * w.prod := by
simp only [base_smul_def', prod, map_mul, mul_assoc]
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod_base_smul | null |
prod_empty : (empty : NormalWord d).prod = 1 := by
simp [prod, empty] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod_empty | null |
@[simps!]
noncomputable cons {i} (g : G i) (w : NormalWord d) (hmw : w.fstIdx ≠ some i)
(hgr : g ∉ (φ i).range) : NormalWord d :=
letI n := (d.compl i).equiv (g * (φ i w.head))
letI w' := Word.cons (n.2 : G i) w.toWord hmw
(mt (coe_equiv_snd_eq_one_iff_mem _ (d.one_mem _)).1
(mt (mul_mem_cancel_right ... | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | cons | A constructor that multiplies a `NormalWord` by an element, with condition to make
sure the underlying list does get longer. |
prod_cons {i} (g : G i) (w : NormalWord d) (hmw : w.fstIdx ≠ some i)
(hgr : g ∉ (φ i).range) : (cons g w hmw hgr).prod = of i g * w.prod := by
simp [prod, cons, ← of_apply_eq_base φ i, equiv_fst_eq_mul_inv, mul_assoc]
variable [DecidableEq ι] [∀ i, DecidableEq (G i)] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod_cons | null |
eq_one_of_smul_normalized (w : CoprodI.Word G) {i : ι} (h : H)
(hw : ∀ i g, ⟨i, g⟩ ∈ w.toList → g ∈ d.set i)
(hφw : ∀ j g, ⟨j, g⟩ ∈ (CoprodI.of (φ i h) • w).toList → g ∈ d.set j) :
h = 1 := by
simp only [← (d.compl _).equiv_snd_eq_self_iff_mem (one_mem _)] at hw hφw
have hhead : ((d.compl i).equiv (Word... | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | eq_one_of_smul_normalized | Given a word in `CoprodI`, if every letter is in the transversal and when
we multiply by an element of the base group it still has this property,
then the element of the base group we multiplied by was one. |
ext_smul {w₁ w₂ : NormalWord d} (i : ι)
(h : CoprodI.of (φ i w₁.head) • w₁.toWord =
CoprodI.of (φ i w₂.head) • w₂.toWord) :
w₁ = w₂ := by
rcases w₁ with ⟨w₁, h₁, hw₁⟩
rcases w₂ with ⟨w₂, h₂, hw₂⟩
dsimp at *
rw [smul_eq_iff_eq_inv_smul, ← mul_smul] at h
subst h
simp only [← map_inv, ← map_mu... | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | ext_smul | null |
noncomputable rcons (i : ι) (p : Pair d i) : NormalWord d :=
letI n := (d.compl i).equiv p.head
let w := (Word.equivPair i).symm { p.toPair with head := n.2 }
{ toWord := w
head := (MonoidHom.ofInjective (d.injective i)).symm n.1
normalized := fun i g hg => by
dsimp [w] at hg
rw [Word.equi... | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | rcons | Given a pair `(head, tail)`, we can form a word by prepending `head` to `tail`, but
putting head into normal form first, by making sure it is expressed as an element
of the base group multiplied by an element of the transversal. |
rcons_injective {i : ι} : Function.Injective (rcons (d := d) i) := by
rintro ⟨⟨head₁, tail₁⟩, _⟩ ⟨⟨head₂, tail₂⟩, _⟩
simp only [rcons, NormalWord.mk.injEq, EmbeddingLike.apply_eq_iff_eq,
Word.Pair.mk.injEq, Pair.mk.injEq, and_imp]
intro h₁ h₂ h₃
subst h₂
rw [← equiv_fst_mul_equiv_snd (d.compl i) head₁,
... | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | rcons_injective | null |
noncomputable equivPair (i) : NormalWord d ≃ Pair d i :=
letI toFun : NormalWord d → Pair d i :=
fun w =>
letI p := Word.equivPair i (CoprodI.of (φ i w.head) • w.toWord)
{ toPair := p
normalized := fun j g hg => by
dsimp only [p] at hg
rw [Word.of_smul_def, ← Word.equivPair... | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | equivPair | The equivalence between `NormalWord`s and pairs. We can turn a `NormalWord` into a
pair by taking the head of the `List` if it is in `G i` and multiplying it by the element of the
base group. |
noncomputable summandAction (i : ι) : MulAction (G i) (NormalWord d) :=
{ smul := fun g w => (equivPair i).symm
{ equivPair i w with
head := g * (equivPair i w).head }
one_smul := fun _ => by
dsimp [instHSMul]
rw [one_mul]
exact (equivPair i).symm_apply_apply _
mul_smul := fun ... | instance | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | summandAction | null |
summand_smul_def' {i : ι} (g : G i) (w : NormalWord d) :
g • w = (equivPair i).symm
{ equivPair i w with
head := g * (equivPair i w).head } := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | summand_smul_def' | null |
noncomputable mulAction : MulAction (PushoutI φ) (NormalWord d) :=
MulAction.ofEndHom <|
lift
(fun _ => MulAction.toEndHom)
MulAction.toEndHom <| by
intro i
simp only [MulAction.toEndHom, DFunLike.ext_iff, MonoidHom.coe_comp, MonoidHom.coe_mk,
OneHom.coe_mk, comp_apply]
intro h
f... | instance | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | mulAction | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.