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 ⌀ |
|---|---|---|---|---|---|---|
base_smul_def (h : H) (w : NormalWord d) :
base φ 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 |
summand_smul_def {i : ι} (g : G i) (w : NormalWord d) :
of (φ := φ) i 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 |
of_smul_eq_smul {i : ι} (g : G i) (w : NormalWord d) :
of (φ := φ) i g • w = g • w := by
rw [summand_smul_def, summand_smul_def'] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | of_smul_eq_smul | null |
base_smul_eq_smul (h : H) (w : NormalWord d) :
base φ h • w = h • w := by
rw [base_smul_def, base_smul_def'] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | base_smul_eq_smul | null |
@[elab_as_elim]
noncomputable consRecOn {motive : NormalWord d → Sort _} (w : NormalWord d)
(empty : motive empty)
(cons : ∀ (i : ι) (g : G i) (w : NormalWord d) (hmw : w.fstIdx ≠ some i)
(_hgn : g ∈ d.set i) (hgr : g ∉ (φ i).range) (_hw1 : w.head = 1),
motive w → motive (cons g w hmw hgr))
(base : ∀ (h : H) (w : NormalWord d), w.head = 1 → motive w → motive
(base φ h • w)) : motive w := by
rcases w with ⟨w, head, h3⟩
convert base head ⟨w, 1, h3⟩ rfl ?_
· simp [base_smul_def]
· induction w using Word.consRecOn with
| empty => exact empty
| cons i g w h1 hg1 ih =>
convert cons i g ⟨w, 1, fun _ _ h => h3 _ _ (List.mem_cons_of_mem _ h)⟩
h1 (h3 _ _ List.mem_cons_self) ?_ rfl
(ih ?_)
· simp only [Word.cons, NormalWord.cons, map_one, mul_one,
(equiv_snd_eq_self_iff_mem (d.compl i) (one_mem _)).2
(h3 _ _ List.mem_cons_self)]
· apply d.injective i
simp only [NormalWord.cons, equiv_fst_eq_mul_inv, MonoidHom.apply_ofInjective_symm,
map_one, mul_one, mul_inv_cancel, (equiv_snd_eq_self_iff_mem (d.compl i) (one_mem _)).2
(h3 _ _ List.mem_cons_self)]
· rwa [← SetLike.mem_coe,
← coe_equiv_snd_eq_one_iff_mem (d.compl i) (d.one_mem _),
(equiv_snd_eq_self_iff_mem (d.compl i) (one_mem _)).2
(h3 _ _ List.mem_cons_self)] | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | consRecOn | Induction principle for `NormalWord`, that corresponds closely to inducting on
the underlying list. |
cons_eq_smul {i : ι} (g : G i)
(w : NormalWord d) (hmw : w.fstIdx ≠ some i)
(hgr : g ∉ (φ i).range) : cons g w hmw hgr = of (φ := φ) i g • w := by
apply ext_smul i
simp only [cons, Word.cons_eq_smul, MonoidHom.apply_ofInjective_symm,
equiv_fst_eq_mul_inv, mul_assoc, map_mul, map_inv, mul_smul, inv_smul_smul, summand_smul_def,
equivPair, rcons, Word.equivPair_symm, Word.rcons_eq_smul, Equiv.coe_fn_mk,
Word.equivPair_tail_eq_inv_smul, Equiv.coe_fn_symm_mk, smul_inv_smul]
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | cons_eq_smul | null |
prod_summand_smul {i : ι} (g : G i) (w : NormalWord d) :
(g • w).prod = of i g * w.prod := by
simp only [prod, summand_smul_def', equivPair, rcons, Word.equivPair_symm,
Equiv.coe_fn_mk, Equiv.coe_fn_symm_mk, Word.equivPair_smul_same,
Word.equivPair_tail_eq_inv_smul, Word.rcons_eq_smul, ← of_apply_eq_base φ i,
MonoidHom.apply_ofInjective_symm, equiv_fst_eq_mul_inv, mul_assoc, map_mul, map_inv,
Word.prod_smul, ofCoprodI_of, inv_mul_cancel_left, mul_inv_cancel_left]
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod_summand_smul | null |
prod_smul (g : PushoutI φ) (w : NormalWord d) :
(g • w).prod = g * w.prod := by
induction g using PushoutI.induction_on generalizing w with
| of i g => rw [of_smul_eq_smul, prod_summand_smul]
| base h => rw [base_smul_eq_smul, prod_base_smul]
| mul x y ihx ihy => rw [mul_smul, ihx, ihy, mul_assoc] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod_smul | null |
prod_smul_empty (w : NormalWord d) : w.prod • empty = w := by
induction w using consRecOn with
| empty => simp
| cons i g w _ _ _ _ ih =>
rw [prod_cons, mul_smul, ih, cons_eq_smul]
| base h w _ ih =>
rw [prod_smul, mul_smul, ih] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod_smul_empty | null |
noncomputable equiv : PushoutI φ ≃ NormalWord d :=
{ toFun := fun g => g • .empty
invFun := fun w => w.prod
left_inv := fun g => by
simp only [prod_smul, prod_empty, mul_one]
right_inv := fun w => prod_smul_empty w } | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | equiv | The equivalence between normal forms and elements of the pushout |
prod_injective {ι : Type*} {G : ι → Type*} [(i : ι) → Group (G i)] {φ : (i : ι) → H →* G i}
{d : Transversal φ} : Function.Injective (prod : NormalWord d → PushoutI φ) := by
letI := Classical.decEq ι
letI := fun i => Classical.decEq (G i)
classical exact equiv.symm.injective | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | prod_injective | null |
of_injective (hφ : ∀ i, Function.Injective (φ i)) (i : ι) :
Function.Injective (of (φ := φ) i) := by
rcases transversal_nonempty φ hφ with ⟨d⟩
let _ := Classical.decEq ι
let _ := fun i => Classical.decEq (G i)
refine Function.Injective.of_comp
(f := ((· • ·) : PushoutI φ → NormalWord d → NormalWord d)) ?_
intro _ _ h
exact eq_of_smul_eq_smul (fun w : NormalWord d =>
by simp_all [funext_iff, of_smul_eq_smul]) | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | of_injective | All maps into the `PushoutI`, or amalgamated product of groups are injective,
provided all maps in the diagram are injective.
See also `base_injective` |
base_injective (hφ : ∀ i, Function.Injective (φ i)) :
Function.Injective (base φ) := by
rcases transversal_nonempty φ hφ with ⟨d⟩
let _ := Classical.decEq ι
let _ := fun i => Classical.decEq (G i)
refine Function.Injective.of_comp
(f := ((· • ·) : PushoutI φ → NormalWord d → NormalWord d)) ?_
intro _ _ h
exact eq_of_smul_eq_smul (fun w : NormalWord d =>
by simp_all [funext_iff, base_smul_eq_smul]) | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | base_injective | null |
Reduced (w : Word G) : Prop :=
∀ g, g ∈ w.toList → g.2 ∉ (φ g.1).range | def | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | Reduced | A word in `CoprodI` is reduced if none of its letters are in the base group. |
Reduced.exists_normalWord_prod_eq (d : Transversal φ) {w : Word G} (hw : Reduced φ w) :
∃ w' : NormalWord d, w'.prod = ofCoprodI w.prod ∧
w'.toList.map Sigma.fst = w.toList.map Sigma.fst := by
classical
induction w using Word.consRecOn with
| empty => exact ⟨empty, by simp, rfl⟩
| cons i g w hIdx hg1 ih =>
rcases ih (fun _ hg => hw _ (List.mem_cons_of_mem _ hg)) with
⟨w', hw'prod, hw'map⟩
refine ⟨cons g w' ?_ ?_, ?_⟩
· rwa [Word.fstIdx, ← List.head?_map, hw'map, List.head?_map]
· exact hw _ List.mem_cons_self
· simp [hw'prod, hw'map] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | Reduced.exists_normalWord_prod_eq | null |
Reduced.eq_empty_of_mem_range
(hφ : ∀ i, Injective (φ i)) {w : Word G} (hw : Reduced φ w)
(h : ofCoprodI w.prod ∈ (base φ).range) : w = .empty := by
rcases transversal_nonempty φ hφ with ⟨d⟩
rcases hw.exists_normalWord_prod_eq d with ⟨w', hw'prod, hw'map⟩
rcases h with ⟨h, heq⟩
have : (NormalWord.prod (d := d) ⟨.empty, h, by simp⟩) = base φ h := by
simp [NormalWord.prod]
rw [← hw'prod, ← this] at heq
suffices w'.toWord = .empty by
simp [this, @eq_comm _ []] at hw'map
ext
simp [hw'map]
rw [← prod_injective heq] | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | Reduced.eq_empty_of_mem_range | For any word `w` in the coproduct,
if `w` is reduced (i.e none its letters are in the image of the base monoid), and nonempty, then
`w` itself is not in the image of the base group. |
inf_of_range_eq_base_range
(hφ : ∀ i, Injective (φ i)) {i j : ι} (hij : i ≠ j) :
(of i).range ⊓ (of j).range = (base φ).range :=
le_antisymm
(by
intro x ⟨⟨g₁, hg₁⟩, ⟨g₂, hg₂⟩⟩
by_contra hx
have hx1 : x ≠ 1 := by rintro rfl; simp_all only [ne_eq, one_mem, not_true_eq_false]
have hg₁1 : g₁ ≠ 1 :=
ne_of_apply_ne (of (φ := φ) i) (by simp_all)
have hg₂1 : g₂ ≠ 1 :=
ne_of_apply_ne (of (φ := φ) j) (by simp_all)
have hg₁r : g₁ ∉ (φ i).range := by
rintro ⟨y, rfl⟩
subst hg₁
exact hx (of_apply_eq_base φ i y ▸ MonoidHom.mem_range.2 ⟨y, rfl⟩)
have hg₂r : g₂ ∉ (φ j).range := by
rintro ⟨y, rfl⟩
subst hg₂
exact hx (of_apply_eq_base φ j y ▸ MonoidHom.mem_range.2 ⟨y, rfl⟩)
let w : Word G := ⟨[⟨_, g₁⟩, ⟨_, g₂⁻¹⟩], by simp_all, by simp_all⟩
have hw : Reduced φ w := by
simp only [w, Reduced, List.mem_cons,
forall_eq_or_imp, not_false_eq_true,
hg₁r, hg₂r, List.mem_nil_iff, false_imp_iff, imp_true_iff, and_true,
inv_mem_iff]
have := hw.eq_empty_of_mem_range hφ (by
simp only [w, Word.prod, List.map_cons, List.prod_cons, List.prod_nil,
List.map_nil, map_mul, ofCoprodI_of, hg₁, hg₂, map_inv, mul_one,
mul_inv_cancel, one_mem])
simp [w, Word.empty] at this)
(le_inf
(by rw [← of_comp_eq_base i]
rintro _ ⟨h, rfl⟩
exact MonoidHom.mem_range.2 ⟨φ i h, rfl⟩)
(by rw [← of_comp_eq_base j]
rintro _ ⟨h, rfl⟩
exact MonoidHom.mem_range.2 ⟨φ j h, rfl⟩)) | theorem | GroupTheory | [
"Mathlib.GroupTheory.CoprodI",
"Mathlib.GroupTheory.Coprod.Basic",
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/PushoutI.lean | inf_of_range_eq_base_range | The intersection of the images of the maps from any two distinct groups in the diagram
into the amalgamated product is the image of the map from the base group in the diagram. |
@[to_additive /-- The minimum number of generators of an additive group. -/]
noncomputable rank [h : FG G] : ℕ := @Nat.find _ (Classical.decPred _) (fg_iff'.mp h)
variable (G) in
@[to_additive] | def | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank | The minimum number of generators of a group. |
rank_spec [h : FG G] : ∃ S : Finset G, S.card = rank G ∧ .closure S = (⊤ : Subgroup G) :=
@Nat.find_spec _ (Classical.decPred _) (fg_iff'.mp h)
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_spec | null |
rank_le [h : FG G] {S : Finset G} (hS : .closure S = (⊤ : Subgroup G)) : rank G ≤ S.card :=
@Nat.find_le _ _ (Classical.decPred _) (fg_iff'.mp h) ⟨S, rfl, hS⟩
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_le | null |
rank_le_of_surjective [FG G] [FG H] (f : G →* H) (hf : Surjective f) : rank H ≤ rank G := by
classical
obtain ⟨S, hS1, hS2⟩ := rank_spec G
trans (S.image f).card
· apply rank_le
rw [Finset.coe_image, ← MonoidHom.map_closure, hS2, Subgroup.map_top_of_surjective f hf]
· exact Finset.card_image_le.trans_eq hS1
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_le_of_surjective | null |
rank_range_le [FG G] {f : G →* H} : rank f.range ≤ rank G :=
rank_le_of_surjective f.rangeRestrict f.rangeRestrict_surjective
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_range_le | null |
rank_congr [FG G] [FG H] (e : G ≃* H) : rank G = rank H :=
le_antisymm (rank_le_of_surjective e.symm e.symm.surjective)
(rank_le_of_surjective e e.surjective) | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_congr | null |
@[to_additive]
rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) : rank H = rank K := by
subst h; rfl
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_congr | null |
rank_closure_finset_le_card (s : Finset G) : rank (closure (s : Set G)) ≤ s.card := by
classical
let t : Finset (closure (s : Set G)) := s.preimage Subtype.val Subtype.coe_injective.injOn
have ht : closure (t : Set (closure (s : Set G))) = ⊤ := by
rw [Finset.coe_preimage]
exact closure_preimage_eq_top (s : Set G)
apply (rank_le ht).trans
suffices H : Set.InjOn Subtype.val (t : Set (closure (s : Set G))) by
rw [← Finset.card_image_of_injOn H, Finset.image_preimage]
apply Finset.card_filter_le
apply Subtype.coe_injective.injOn
@[to_additive] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_closure_finset_le_card | null |
rank_closure_finite_le_nat_card (s : Set G) [Finite s] : rank (closure s) ≤ Nat.card s := by
haveI := Fintype.ofFinite s
rw [Nat.card_eq_fintype_card, ← s.toFinset_card, ← rank_congr (congr_arg _ s.coe_toFinset)]
exact rank_closure_finset_le_card s.toFinset | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | rank_closure_finite_le_nat_card | null |
nat_card_centralizer_nat_card_stabilizer (g : G) :
Nat.card (centralizer {g}) = Nat.card (MulAction.stabilizer (ConjAct G) g) := by
rw [centralizer_eq_comap_stabilizer]; rfl | lemma | GroupTheory | [
"Mathlib.GroupTheory.Finiteness",
"Mathlib.SetTheory.Cardinal.Finite"
] | Mathlib/GroupTheory/Rank.lean | nat_card_centralizer_nat_card_stabilizer | null |
@[ext]
RegularWreathProduct where
/-- The function of Q → D -/
left : Q → D
/-- The element of Q -/
right : Q
@[inherit_doc] infix:65 " ≀ᵣ " => RegularWreathProduct | structure | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | RegularWreathProduct | The regular wreath product of groups `Q` and `D`. It is the product `(Q → D) × Q` with the group
operation `⟨a₁, a₂⟩ * ⟨b₁, b₂⟩ = ⟨a₁ * (fun x ↦ b₁ (a₂⁻¹ * x)), a₂ * b₂⟩`. |
mul_def (a b : D ≀ᵣ Q) : a * b = ⟨a.1 * fun x ↦ b.1 (a.2⁻¹ * x), a.2 * b.2⟩ := rfl
@[simp] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | mul_def | null |
mul_left (a b : D ≀ᵣ Q) : (a * b).1 = a.1 * fun x ↦ b.1 (a.2⁻¹ * x) := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | mul_left | null |
mul_right (a b : D ≀ᵣ Q) : (a * b).right = a.right * b.right := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | mul_right | null |
@[simp]
one_left : (1 : D ≀ᵣ Q).left = 1 := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | one_left | null |
one_right : (1 : D ≀ᵣ Q).right = 1 := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | one_right | null |
@[simp]
inv_left (a : D ≀ᵣ Q) : a⁻¹.left = fun x ↦ a.left⁻¹ (a.right * x) := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | inv_left | null |
inv_right (a : D ≀ᵣ Q) : a⁻¹.right = a.right⁻¹ := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | inv_right | null |
rightHom : D ≀ᵣ Q →* Q where
toFun := RegularWreathProduct.right
map_one' := rfl
map_mul' _ _ := rfl | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | rightHom | The canonical projection map `D ≀ᵣ Q →* Q`, as a group hom. |
inl : Q →* D ≀ᵣ Q where
toFun q := ⟨1, q⟩
map_one' := rfl
map_mul' _ _ := by ext <;> simp
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | inl | The canonical map `Q →* D ≀ᵣ Q` sending `q` to `⟨1, q⟩` |
left_inl (q : Q) : (inl q : D ≀ᵣ Q).left = 1 := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | left_inl | null |
right_inl (q : Q) : (inl q : D ≀ᵣ Q).right = q := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | right_inl | null |
rightHom_eq_right : (rightHom : D ≀ᵣ Q → Q) = right := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | rightHom_eq_right | null |
rightHom_comp_inl_eq_id : (rightHom : D ≀ᵣ Q →* Q).comp inl = MonoidHom.id _ := by ext; simp
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | rightHom_comp_inl_eq_id | null |
fun_id (q : Q) : rightHom (inl q : D ≀ᵣ Q) = q := by simp | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | fun_id | null |
equivProd D Q : D ≀ᵣ Q ≃ (Q → D) × Q where
toFun := fun ⟨d, q⟩ => ⟨d, q⟩
invFun := fun ⟨d, q⟩ => ⟨d, q⟩
left_inv := fun _ => rfl
right_inv := fun _ => rfl | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | equivProd | The equivalence map for the representation as a product. |
card [Finite Q] : Nat.card (D ≀ᵣ Q) = Nat.card D ^ Nat.card Q * Nat.card Q := by
rw [Nat.card_congr (equivProd D Q), Nat.card_prod (Q → D) Q, Nat.card_fun] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | card | null |
congr {D₁ Q₁ D₂ Q₂ : Type*} [Group D₁] [Group Q₁] [Group D₂] [Group Q₂]
(f : D₁ ≃* D₂) (g : Q₁ ≃* Q₂) :
D₁ ≀ᵣ Q₁ ≃* D₂ ≀ᵣ Q₂ where
toFun x := ⟨f ∘ (x.left ∘ g.symm), g x.right⟩
invFun x := ⟨(f.symm ∘ x.left) ∘ g, g.symm x.right⟩
left_inv x := by ext <;> simp
right_inv x := by ext <;> simp
map_mul' x y := by ext <;> simp | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | congr | Define an isomorphism from `D₁ ≀ᵣ Q₁` to `D₂ ≀ᵣ Q₂`
given isomorphisms `D₁ ≀ᵣ Q₁` and `Q₁ ≃* Q₂`. |
@[simp]
smul_def {w : D ≀ᵣ Q} {p : Λ × Q} : w • p = ⟨(w.1 (w.2 * p.2)) • p.1, w.2 * p.2⟩ := rfl | lemma | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | smul_def | null |
toPerm : D ≀ᵣ Q →* Equiv.Perm (Λ × Q) :=
MulAction.toPermHom (D ≀ᵣ Q) (Λ × Q) | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | toPerm | The map sending the wreath product `D ≀ᵣ Q` to its representation as a permutation of `Λ × Q`
given `D`-set `Λ`. |
toPermInj [Nonempty Λ] : Function.Injective (toPerm D Q Λ) := MulAction.toPerm_injective | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | toPermInj | null |
IteratedWreathProduct (G : Type u) : (n : ℕ) → Type u
| 0 => PUnit
| n + 1 => (IteratedWreathProduct G n) ≀ᵣ G
variable (G : Type u) (n : ℕ)
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | IteratedWreathProduct | The wreath product of group `G` iterated `n` times. |
IteratedWreathProduct_zero : IteratedWreathProduct G 0 = PUnit := rfl
@[simp] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | IteratedWreathProduct_zero | null |
IteratedWreathProduct_succ :
IteratedWreathProduct G (n + 1) = (IteratedWreathProduct G n) ≀ᵣ G := rfl | lemma | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | IteratedWreathProduct_succ | null |
IteratedWreathProduct.card [Finite G] : Nat.card (IteratedWreathProduct G n) =
Nat.card G ^ (∑ i ∈ Finset.range n, Nat.card G ^ i) := by
induction n with
| zero => simp
| succ n h => rw [IteratedWreathProduct_succ, RegularWreathProduct.card,
h, geom_sum_succ, pow_succ, pow_mul']
variable [Group G] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | IteratedWreathProduct.card | null |
iteratedWreathToPermHom (G : Type*) [Group G] :
(n : ℕ) → (IteratedWreathProduct G n →* Equiv.Perm (Fin n → G))
| 0 => 1
| n + 1 => by
let _ := MulAction.compHom (Fin n → G) (iteratedWreathToPermHom G n)
exact (Fin.succFunEquiv G n).symm.permCongrHom.toMonoidHom.comp
(RegularWreathProduct.toPerm (IteratedWreathProduct G n) G (Fin n → G)) | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | iteratedWreathToPermHom | The homomorphism from `IteratedWreathProduct G n` to `Perm (Fin n → G)`. |
iteratedWreathToPermHomInj (G : Type*) [Group G] :
(n : ℕ) → Function.Injective (iteratedWreathToPermHom G n)
| 0 => by
simp only [IteratedWreathProduct_zero]
apply Function.injective_of_subsingleton
| n + 1 => by
let _ := MulAction.compHom (Fin n → G) (iteratedWreathToPermHom G n)
have : FaithfulSMul (IteratedWreathProduct G n) (Fin n → G) :=
⟨fun h ↦ iteratedWreathToPermHomInj G n (Equiv.ext h)⟩
exact ((Fin.succFunEquiv G n).symm.permCongrHom.toEquiv.comp_injective _).mpr
(RegularWreathProduct.toPermInj (IteratedWreathProduct G n) G (Fin n → G)) | lemma | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | iteratedWreathToPermHomInj | null |
noncomputable Sylow.mulEquivIteratedWreathProduct (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
(α : Type*) [Finite α] (hα : Nat.card α = p ^ n)
(G : Type*) [Group G] [Finite G] (hG : Nat.card G = p)
(P : Sylow p (Equiv.Perm α)) :
P ≃* IteratedWreathProduct G n := by
let e1 : α ≃ (Fin n → G) := (Finite.equivFinOfCardEq hα).trans
(Finite.equivFinOfCardEq (by rw [Nat.card_fun, Nat.card_fin, hG])).symm
let f := e1.symm.permCongrHom.toMonoidHom.comp (iteratedWreathToPermHom G n)
have hf : Function.Injective f :=
(e1.symm.permCongrHom.comp_injective _).mpr (iteratedWreathToPermHomInj G n)
let g := (MonoidHom.ofInjective hf).symm
let P' : Sylow p (Equiv.Perm α) := Sylow.ofCard (MonoidHom.range f) (by
rw [Nat.card_congr g.toEquiv, IteratedWreathProduct.card, hG, Nat.card_perm, hα,
← Nat.multiplicity_eq_factorization hp.out (p ^ n).factorial_ne_zero,
Nat.Prime.multiplicity_factorial_pow hp.out])
exact (P.equiv P').trans g | def | GroupTheory | [
"Mathlib.GroupTheory.Sylow",
"Mathlib.Algebra.Group.PUnit",
"Mathlib.Data.Finite.Perm",
"Mathlib.Algebra.Group.End"
] | Mathlib/GroupTheory/RegularWreathProduct.lean | Sylow.mulEquivIteratedWreathProduct | The encoding of the Sylow `p`-subgroups of `Perm α` as an iterated wreath product. |
@[to_additive]
card_dvd_exponent_pow_rank : Nat.card G ∣ Monoid.exponent G ^ Group.rank G := by
classical
obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
rw [← hS1, ← Fintype.card_coe, ← Finset.card_univ, ← Finset.prod_const]
let f : (∀ g : S, zpowers (g : G)) →* G := noncommPiCoprod fun s t _ x y _ _ => mul_comm x _
have hf : Function.Surjective f := by
rw [← MonoidHom.range_eq_top, eq_top_iff, ← hS2, closure_le]
exact fun g hg => ⟨Pi.mulSingle ⟨g, hg⟩ ⟨g, mem_zpowers g⟩, noncommPiCoprod_mulSingle _ _⟩
replace hf := card_dvd_of_surjective f hf
rw [Nat.card_pi] at hf
refine hf.trans (Finset.prod_dvd_prod_of_dvd _ _ fun g _ => ?_)
rw [Nat.card_zpowers]
exact Monoid.order_dvd_exponent (g : G)
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | card_dvd_exponent_pow_rank | null |
card_dvd_exponent_pow_rank' {n : ℕ} (hG : ∀ g : G, g ^ n = 1) :
Nat.card G ∣ n ^ Group.rank G :=
(card_dvd_exponent_pow_rank G).trans
(pow_dvd_pow_of_dvd (Monoid.exponent_dvd_of_forall_pow_eq_one hG) (Group.rank G)) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | card_dvd_exponent_pow_rank' | null |
closure_mul_image_mul_eq_top
(hR : IsComplement H R) (hR1 : (1 : G) ∈ R) (hS : closure S = ⊤) :
(closure ((R * S).image fun g => g * (hR.toRightFun g : G)⁻¹)) * R = ⊤ := by
let f : G → R := hR.toRightFun
let U : Set G := (R * S).image fun g => g * (f g : G)⁻¹
change (closure U : Set G) * R = ⊤
refine top_le_iff.mp fun g _ => ?_
refine closure_induction_right ?_ ?_ ?_ (eq_top_iff.mp hS (mem_top g))
· exact ⟨1, (closure U).one_mem, 1, hR1, one_mul 1⟩
· rintro - - s hs ⟨u, hu, r, hr, rfl⟩
rw [show u * r * s = u * (r * s * (f (r * s) : G)⁻¹) * f (r * s) by group]
refine Set.mul_mem_mul ((closure U).mul_mem hu ?_) (f (r * s)).coe_prop
exact subset_closure ⟨r * s, Set.mul_mem_mul hr hs, rfl⟩
· rintro - - s hs ⟨u, hu, r, hr, rfl⟩
rw [show u * r * s⁻¹ = u * (f (r * s⁻¹) * s * r⁻¹)⁻¹ * f (r * s⁻¹) by group]
refine Set.mul_mem_mul ((closure U).mul_mem hu ((closure U).inv_mem ?_)) (f (r * s⁻¹)).2
refine subset_closure ⟨f (r * s⁻¹) * s, Set.mul_mem_mul (f (r * s⁻¹)).2 hs, ?_⟩
rw [mul_right_inj, inv_inj, ← Subtype.coe_mk r hr, ← Subtype.ext_iff, Subtype.coe_mk]
apply (isComplement_iff_existsUnique_mul_inv_mem.mp hR (f (r * s⁻¹) * s)).unique
(hR.mul_inv_toRightFun_mem (f (r * s⁻¹) * s))
rw [mul_assoc, ← inv_inv s, ← mul_inv_rev, inv_inv]
exact hR.toRightFun_mul_inv_mem (r * s⁻¹) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | closure_mul_image_mul_eq_top | null |
closure_mul_image_eq (hR : IsComplement H R) (hR1 : (1 : G) ∈ R)
(hS : closure S = ⊤) : closure ((R * S).image fun g => g * (hR.toRightFun g : G)⁻¹) = H := by
have hU : closure ((R * S).image fun g => g * (hR.toRightFun g : G)⁻¹) ≤ H := by
rw [closure_le]
rintro - ⟨g, -, rfl⟩
exact hR.mul_inv_toRightFun_mem g
refine le_antisymm hU fun h hh => ?_
obtain ⟨g, hg, r, hr, rfl⟩ :=
show h ∈ _ from eq_top_iff.mp (closure_mul_image_mul_eq_top hR hR1 hS) (mem_top h)
suffices (⟨r, hr⟩ : R) = (⟨1, hR1⟩ : R) by
simpa only [show r = 1 from Subtype.ext_iff.mp this, mul_one]
apply (isComplement_iff_existsUnique_mul_inv_mem.mp hR r).unique
· rw [Subtype.coe_mk, mul_inv_cancel]
exact H.one_mem
· rw [Subtype.coe_mk, inv_one, mul_one]
exact (H.mul_mem_cancel_left (hU hg)).mp hh | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | closure_mul_image_eq | **Schreier's Lemma**: If `R : Set G` is a `rightTransversal` of `H : Subgroup G`
with `1 ∈ R`, and if `G` is generated by `S : Set G`, then `H` is generated by the `Set`
`(R * S).image (fun g ↦ g * (hR.toRightFun g)⁻¹)`. |
closure_mul_image_eq_top (hR : IsComplement H R) (hR1 : (1 : G) ∈ R)
(hS : closure S = ⊤) : closure ((R * S).image fun g =>
⟨g * (hR.toRightFun g : G)⁻¹, hR.mul_inv_toRightFun_mem g⟩ : Set H) = ⊤ := by
rw [eq_top_iff, ← map_subtype_le_map_subtype, MonoidHom.map_closure, Set.image_image]
exact (map_subtype_le ⊤).trans (ge_of_eq (closure_mul_image_eq hR hR1 hS)) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | closure_mul_image_eq_top | **Schreier's Lemma**: If `R : Set G` is a `rightTransversal` of `H : Subgroup G`
with `1 ∈ R`, and if `G` is generated by `S : Set G`, then `H` is generated by the `Set`
`(R * S).image (fun g ↦ g * (hR.toRightFun g)⁻¹)`. |
closure_mul_image_eq_top' [DecidableEq G] {R S : Finset G}
(hR : IsComplement (H : Set G) R) (hR1 : (1 : G) ∈ R)
(hS : closure (S : Set G) = ⊤) :
closure (((R * S).image fun g => ⟨_, hR.mul_inv_toRightFun_mem g⟩ : Finset H) : Set H) = ⊤ := by
rw [Finset.coe_image, Finset.coe_mul]
exact closure_mul_image_eq_top hR hR1 hS
variable (H) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | closure_mul_image_eq_top' | **Schreier's Lemma**: If `R : Finset G` is a `rightTransversal` of `H : Subgroup G`
with `1 ∈ R`, and if `G` is generated by `S : Finset G`, then `H` is generated by the `Finset`
`(R * S).image (fun g ↦ g * (hR.toRightFun g)⁻¹)`. |
exists_finset_card_le_mul [FiniteIndex H] {S : Finset G} (hS : closure (S : Set G) = ⊤) :
∃ T : Finset H, #T ≤ H.index * #S ∧ closure (T : Set H) = ⊤ := by
letI := H.fintypeQuotientOfFiniteIndex
haveI : DecidableEq G := Classical.decEq G
obtain ⟨R₀, hR, hR1⟩ := H.exists_isComplement_right 1
haveI : Fintype R₀ := Fintype.ofEquiv _ hR.rightQuotientEquiv
let R : Finset G := Set.toFinset R₀
replace hR : IsComplement (H : Set G) R := by rwa [Set.coe_toFinset]
replace hR1 : (1 : G) ∈ R := by rwa [Set.mem_toFinset]
refine ⟨_, ?_, closure_mul_image_eq_top' hR hR1 hS⟩
calc
_ ≤ #(R * S) := Finset.card_image_le
_ ≤ #R * #S := Finset.card_mul_le
_ = H.index * S.card := congr_arg (· * S.card) ?_
calc
#R = Fintype.card R := (Fintype.card_coe R).symm
_ = _ := (Fintype.card_congr hR.rightQuotientEquiv).symm
_ = Fintype.card (G ⧸ H) := QuotientGroup.card_quotient_rightRel H
_ = H.index := by rw [index_eq_card, Nat.card_eq_fintype_card] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | exists_finset_card_le_mul | null |
fg_of_index_ne_zero [hG : Group.FG G] [FiniteIndex H] : Group.FG H := by
obtain ⟨S, hS⟩ := hG.1
obtain ⟨T, -, hT⟩ := exists_finset_card_le_mul H hS
exact ⟨⟨T, hT⟩⟩ | instance | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | fg_of_index_ne_zero | **Schreier's Lemma**: A finite index subgroup of a finitely generated
group is finitely generated. |
rank_le_index_mul_rank [hG : Group.FG G] [FiniteIndex H] :
Group.rank H ≤ H.index * Group.rank G := by
haveI := H.fg_of_index_ne_zero
obtain ⟨S, hS₀, hS⟩ := Group.rank_spec G
obtain ⟨T, hT₀, hT⟩ := exists_finset_card_le_mul H hS
calc
Group.rank H ≤ #T := Group.rank_le hT
_ ≤ H.index * #S := hT₀
_ = H.index * Group.rank G := congr_arg (H.index * ·) hS₀
variable (G) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | rank_le_index_mul_rank | null |
card_commutator_dvd_index_center_pow [Finite (commutatorSet G)] :
Nat.card (_root_.commutator G) ∣
(center G).index ^ ((center G).index * Nat.card (commutatorSet G) + 1) := by
by_cases hG : (center G).index = 0
· simp_rw [hG, zero_mul, zero_add, pow_one, dvd_zero]
haveI : FiniteIndex (center G) := ⟨hG⟩
rw [← ((center G).subgroupOf (_root_.commutator G)).card_mul_index, pow_succ]
have h1 := relIndex_dvd_index_of_normal (center G) (_root_.commutator G)
refine mul_dvd_mul ?_ h1
haveI : FiniteIndex ((center G).subgroupOf (_root_.commutator G)) :=
⟨ne_zero_of_dvd_ne_zero hG h1⟩
have h2 := rank_le_index_mul_rank ((center G).subgroupOf (_root_.commutator G))
have h3 := Nat.mul_le_mul (Nat.le_of_dvd (Nat.pos_of_ne_zero hG) h1) (rank_commutator_le_card G)
refine dvd_trans ?_ (pow_dvd_pow (center G).index (h2.trans h3))
apply card_dvd_exponent_pow_rank'
intro g
have := Abelianization.commutator_subset_ker (MonoidHom.transferCenterPow G) g.1.2
simpa only [MonoidHom.mem_ker, Subtype.ext_iff] using this | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | card_commutator_dvd_index_center_pow | If `G` has `n` commutators `[g₁, g₂]`, then `|G'| ∣ [G : Z(G)] ^ ([G : Z(G)] * n + 1)`,
where `G'` denotes the commutator of `G`. |
cardCommutatorBound (n : ℕ) :=
(n ^ (2 * n)) ^ (n ^ (2 * n + 1) + 1) | def | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | cardCommutatorBound | A bound for the size of the commutator subgroup in terms of the number of commutators. |
card_commutator_le_of_finite_commutatorSet [Finite (commutatorSet G)] :
Nat.card (_root_.commutator G) ≤ cardCommutatorBound (Nat.card (commutatorSet G)) := by
have h1 := index_center_le_pow (closureCommutatorRepresentatives G)
have h2 := card_commutator_dvd_index_center_pow (closureCommutatorRepresentatives G)
rw [card_commutatorSet_closureCommutatorRepresentatives] at h1 h2
rw [card_commutator_closureCommutatorRepresentatives] at h2
replace h1 :=
h1.trans
(Nat.pow_le_pow_right Finite.card_pos (rank_closureCommutatorRepresentatives_le G))
replace h2 := h2.trans (pow_dvd_pow _ (add_le_add_right (mul_le_mul_right' h1 _) 1))
rw [← pow_succ] at h2
refine (Nat.le_of_dvd ?_ h2).trans (Nat.pow_le_pow_left h1 _)
exact pow_pos (Nat.pos_of_ne_zero FiniteIndex.index_ne_zero) _ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Pointwise.Finset.Basic",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.GroupTheory.Commutator.Finite",
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/Schreier.lean | card_commutator_le_of_finite_commutatorSet | A theorem of Schur: The size of the commutator subgroup is bounded in terms of the number of
commutators. |
QuotientDiff :=
Quotient
(Setoid.mk (fun α β => diff (MonoidHom.id H) α β = 1)
⟨fun α => diff_self (MonoidHom.id H) α, fun h => by rw [← diff_inv, h, inv_one],
fun h h' => by rw [← diff_mul_diff, h, h', one_mul]⟩) | def | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | QuotientDiff | The quotient of the transversals of an abelian normal `N` by the `diff` relation. |
smul_diff_smul' [hH : Normal H] (g : Gᵐᵒᵖ) :
diff (MonoidHom.id H) (g • α) (g • β) =
⟨g.unop⁻¹ * (diff (MonoidHom.id H) α β : H) * g.unop,
hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩ := by
letI := H.fintypeQuotientOfFiniteIndex
let ϕ : H →* H :=
{ toFun := fun h =>
⟨g.unop⁻¹ * h * g.unop,
hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩
map_one' := by rw [Subtype.ext_iff, coe_mk, coe_one, mul_one, inv_mul_cancel]
map_mul' := fun h₁ h₂ => by
simp only [Subtype.ext_iff, coe_mul, mul_assoc, mul_inv_cancel_left] }
refine (Fintype.prod_equiv (MulAction.toPerm g).symm _ _ fun x ↦ ?_).trans (map_prod ϕ _ _).symm
simp only [ϕ, smul_apply_eq_smul_apply_inv_smul, smul_eq_mul_unop, mul_inv_rev, mul_assoc,
MonoidHom.id_apply, toPerm_symm_apply, MonoidHom.coe_mk, OneHom.coe_mk]
variable {H}
variable [Normal H] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | smul_diff_smul' | null |
smul_diff' (h : H) :
diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index := by
letI := H.fintypeQuotientOfFiniteIndex
rw [diff, diff, index_eq_card, Nat.card_eq_fintype_card,
← Finset.card_univ, ← Finset.prod_const, ← Finset.prod_mul_distrib]
refine Finset.prod_congr rfl fun q _ => ?_
simp_rw [Subtype.ext_iff, MonoidHom.id_apply, coe_mul, mul_assoc, mul_right_inj]
rw [smul_apply_eq_smul_apply_inv_smul, smul_eq_mul_unop, MulOpposite.unop_op, mul_left_inj,
← Subtype.ext_iff, Equiv.apply_eq_iff_eq, inv_smul_eq_iff]
exact left_eq_mul.mpr ((QuotientGroup.eq_one_iff _).mpr h.2) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | smul_diff' | null |
eq_one_of_smul_eq_one (hH : Nat.Coprime (Nat.card H) H.index) (α : H.QuotientDiff)
(h : H) : h • α = α → h = 1 :=
Quotient.inductionOn' α fun α hα =>
(powCoprime hH).injective <|
calc
h ^ H.index = diff (MonoidHom.id H) (op ((h⁻¹ : H) : G) • α) α := by
rw [← diff_inv, smul_diff', diff_self, one_mul, inv_pow, inv_inv]
_ = 1 ^ H.index := (Quotient.exact' hα).trans (one_pow H.index).symm | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | eq_one_of_smul_eq_one | null |
exists_smul_eq (hH : Nat.Coprime (Nat.card H) H.index) (α β : H.QuotientDiff) :
∃ h : H, h • α = β :=
Quotient.inductionOn' α
(Quotient.inductionOn' β fun β α =>
Exists.imp (fun _ => Quotient.sound')
⟨(powCoprime hH).symm (diff (MonoidHom.id H) β α),
(diff_inv _ _ _).symm.trans
(inv_eq_one.mpr
((smul_diff' β α ((powCoprime hH).symm (diff (MonoidHom.id H) β α))⁻¹).trans
(by rw [inv_pow, ← powCoprime_apply hH, Equiv.apply_symm_apply, mul_inv_cancel])))⟩) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | exists_smul_eq | null |
isComplement'_stabilizer_of_coprime {α : H.QuotientDiff}
(hH : Nat.Coprime (Nat.card H) H.index) : IsComplement' H (stabilizer G α) :=
isComplement'_stabilizer α (eq_one_of_smul_eq_one hH α) fun g => exists_smul_eq hH (g • α) α | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | isComplement'_stabilizer_of_coprime | null |
private exists_right_complement'_of_coprime_aux (hH : Nat.Coprime (Nat.card H) H.index) :
∃ K : Subgroup G, IsComplement' H K :=
have ne : Nonempty (QuotientDiff H) := inferInstance
ne.elim fun α => ⟨stabilizer G α, isComplement'_stabilizer_of_coprime hH⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | exists_right_complement'_of_coprime_aux | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private step0 : N ≠ ⊥ := by
rintro rfl
exact h3 ⊤ isComplement'_bot_top
variable [Finite G]
include h2 in | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step0 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤ := by
contrapose! h3
have h4 : (N.comap K.subtype).index = N.index := by
rw [← N.relIndex_top_right, ← hK]
exact (relIndex_sup_right K N).symm
have h5 : Nat.card K < Nat.card G := by
rw [← K.index_mul_card]
exact lt_mul_of_one_lt_left Nat.card_pos (one_lt_index_of_ne_top h3)
have h6 : Nat.Coprime (Nat.card (N.comap K.subtype)) (N.comap K.subtype).index := by
rw [h4]
exact h1.coprime_dvd_left (card_comap_dvd_of_injective N K.subtype Subtype.coe_injective)
obtain ⟨H, hH⟩ := h2 K h5 h6
replace hH : Nat.card (H.map K.subtype) = N.index := by
rw [← relIndex_bot_left, ← relIndex_comap, MonoidHom.comap_bot, Subgroup.ker_subtype,
relIndex_bot_left, ← IsComplement'.index_eq_card (IsComplement'.symm hH), index_comap,
range_subtype, ← relIndex_sup_right, hK, relIndex_top_right]
have h7 : Nat.card N * Nat.card (H.map K.subtype) = Nat.card G := by
rw [hH, ← N.index_mul_card, mul_comm]
have h8 : (Nat.card N).Coprime (Nat.card (H.map K.subtype)) := by
rwa [hH]
exact ⟨H.map K.subtype, isComplement'_of_coprime h7 h8⟩
include h2 in | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step1 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private step2 (K : Subgroup G) [K.Normal] (hK : K ≤ N) : K = ⊥ ∨ K = N := by
have : Function.Surjective (QuotientGroup.mk' K) := Quotient.mk''_surjective
have h4 := step1 h1 h2 h3
contrapose! h4
have h5 : Nat.card (G ⧸ K) < Nat.card G := by
rw [← index_eq_card, ← K.index_mul_card]
refine
lt_mul_of_one_lt_right (Nat.pos_of_ne_zero index_ne_zero_of_finite)
(K.one_lt_card_iff_ne_bot.mpr h4.1)
have h6 :
(Nat.card (N.map (QuotientGroup.mk' K))).Coprime (N.map (QuotientGroup.mk' K)).index := by
have index_map := N.index_map_eq this (by rwa [QuotientGroup.ker_mk'])
have index_pos : 0 < N.index := Nat.pos_of_ne_zero index_ne_zero_of_finite
rw [index_map]
refine h1.coprime_dvd_left ?_
rw [← Nat.mul_dvd_mul_iff_left index_pos, index_mul_card, ← index_map, index_mul_card]
exact K.card_quotient_dvd_card
obtain ⟨H, hH⟩ := h2 (G ⧸ K) h5 h6
refine ⟨H.comap (QuotientGroup.mk' K), ?_, ?_⟩
· have key : (N.map (QuotientGroup.mk' K)).comap (QuotientGroup.mk' K) = N := by
refine comap_map_eq_self ?_
rwa [QuotientGroup.ker_mk']
rwa [← key, comap_sup_eq, hH.symm.sup_eq_top, comap_top]
· rw [← comap_top (QuotientGroup.mk' K)]
intro hH'
rw [comap_injective this hH', isComplement'_top_right, map_eq_bot_iff,
QuotientGroup.ker_mk'] at hH
exact h4.2 (le_antisymm hK hH)
include h2 in | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step2 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private step3 (K : Subgroup N) [(K.map N.subtype).Normal] : K = ⊥ ∨ K = ⊤ := by
have key := step2 h1 h2 h3 (K.map N.subtype) (map_subtype_le K)
rw [← map_bot N.subtype] at key
conv at key =>
rhs
rhs
rw [← N.range_subtype, N.subtype.range_eq_map]
have inj := map_injective N.subtype_injective
rwa [inj.eq_iff, inj.eq_iff] at key | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step3 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private step4 : (Nat.card N).minFac.Prime :=
Nat.minFac_prime (N.one_lt_card_iff_ne_bot.mpr (step0 h1 h3)).ne' | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step4 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private step5 {P : Sylow (Nat.card N).minFac N} : P.1 ≠ ⊥ := by
haveI : Fact (Nat.card N).minFac.Prime := ⟨step4 h1 h3⟩
apply P.ne_bot_of_dvd_card
exact (Nat.card N).minFac_dvd
include h2 in | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step5 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private step6 : IsPGroup (Nat.card N).minFac N := by
haveI : Fact (Nat.card N).minFac.Prime := ⟨step4 h1 h3⟩
refine Sylow.nonempty.elim fun P => P.2.of_surjective P.1.subtype ?_
rw [← MonoidHom.range_eq_top, range_subtype]
haveI : (P.1.map N.subtype).Normal :=
normalizer_eq_top_iff.mp (step1 h1 h2 h3 (P.map N.subtype).normalizer P.normalizer_sup_eq_top)
exact (step3 h1 h2 h3 P.1).resolve_left (step5 h1 h3)
include h2 in | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step6 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
step7 : IsMulCommutative N := by
haveI := N.bot_or_nontrivial.resolve_left (step0 h1 h3)
haveI : Fact (Nat.card N).minFac.Prime := ⟨step4 h1 h3⟩
exact
⟨⟨fun g h => ((eq_top_iff.mp ((step3 h1 h2 h3 (center N)).resolve_left
(step6 h1 h2 h3).bot_lt_center.ne') (mem_top h)).comm g).symm⟩⟩ | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | step7 | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
private exists_right_complement'_of_coprime_aux' [Finite G] (hG : Nat.card G = n)
{N : Subgroup G} [N.Normal] (hN : Nat.Coprime (Nat.card N) N.index) :
∃ H : Subgroup G, IsComplement' N H := by
revert G
induction n using Nat.strongRecOn with | ind n ih => ?_
rintro G _ _ rfl N _ hN
refine not_forall_not.mp fun h3 => ?_
haveI := SchurZassenhausInduction.step7 hN (fun G' _ _ hG' => by apply ih _ hG'; rfl) h3
exact not_exists_of_forall_not h3 (exists_right_complement'_of_coprime_aux hN) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | exists_right_complement'_of_coprime_aux' | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` |
exists_right_complement'_of_coprime {N : Subgroup G} [N.Normal]
(hN : Nat.Coprime (Nat.card N) N.index) : ∃ H : Subgroup G, IsComplement' N H := by
by_cases hN1 : Nat.card N = 0
· rw [hN1, Nat.coprime_zero_left, index_eq_one] at hN
rw [hN]
exact ⟨⊥, isComplement'_top_bot⟩
by_cases hN2 : N.index = 0
· rw [hN2, Nat.coprime_zero_right] at hN
haveI := (Cardinal.toNat_eq_one_iff_unique.mp hN).1
rw [N.eq_bot_of_subsingleton]
exact ⟨⊤, isComplement'_bot_top⟩
have hN3 : Nat.card G ≠ 0 := by
rw [← N.card_mul_index]
exact mul_ne_zero hN1 hN2
haveI := (Cardinal.lt_aleph0_iff_fintype.mp
(lt_of_not_ge (mt Cardinal.toNat_apply_of_aleph0_le hN3))).some
exact exists_right_complement'_of_coprime_aux' rfl hN | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | exists_right_complement'_of_coprime | **Schur-Zassenhaus** for normal subgroups:
If `H : Subgroup G` is normal, and has order coprime to its index, then there exists a
subgroup `K` which is a (right) complement of `H`. |
exists_left_complement'_of_coprime {N : Subgroup G} [N.Normal]
(hN : Nat.Coprime (Nat.card N) N.index) : ∃ H : Subgroup G, IsComplement' H N :=
Exists.imp (fun _ => IsComplement'.symm) (exists_right_complement'_of_coprime hN) | theorem | GroupTheory | [
"Mathlib.GroupTheory.Transfer"
] | Mathlib/GroupTheory/SchurZassenhaus.lean | exists_left_complement'_of_coprime | **Schur-Zassenhaus** for normal subgroups:
If `H : Subgroup G` is normal, and has order coprime to its index, then there exists a
subgroup `K` which is a (left) complement of `H`. |
@[ext]
SemidirectProduct (φ : G →* MulAut N) where
/-- The element of N -/
left : N
/-- The element of G -/
right : G
deriving DecidableEq
attribute [pp_using_anonymous_constructor] SemidirectProduct
@[inherit_doc]
notation:35 N " ⋊[" φ:35 "] " G:35 => SemidirectProduct N G φ | structure | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | SemidirectProduct | The semidirect product of groups `N` and `G`, given a map `φ` from `G` to the automorphism
group of `N`. It the product of sets with the group operation
`⟨n₁, g₁⟩ * ⟨n₂, g₂⟩ = ⟨n₁ * φ g₁ n₂, g₁ * g₂⟩` |
mul_def (a b : SemidirectProduct N G φ) : a * b = ⟨a.1 * φ a.2 b.1, a.2 * b.2⟩ := rfl
@[simp] | lemma | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | mul_def | null |
mul_left (a b : N ⋊[φ] G) : (a * b).left = a.left * φ a.right b.left := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | mul_left | null |
mul_right (a b : N ⋊[φ] G) : (a * b).right = a.right * b.right := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | mul_right | null |
@[simp]
one_left : (1 : N ⋊[φ] G).left = 1 := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | one_left | null |
one_right : (1 : N ⋊[φ] G).right = 1 := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | one_right | null |
@[simp]
inv_left (a : N ⋊[φ] G) : a⁻¹.left = φ a.right⁻¹ a.left⁻¹ := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | inv_left | null |
inv_right (a : N ⋊[φ] G) : a⁻¹.right = a.right⁻¹ := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | inv_right | null |
inl : N →* N ⋊[φ] G where
toFun n := ⟨n, 1⟩
map_one' := rfl
map_mul' := by intros; ext <;>
simp only [mul_left, map_one, MulAut.one_apply, mul_right, mul_one]
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | inl | The canonical map `N →* N ⋊[φ] G` sending `n` to `⟨n, 1⟩` |
left_inl (n : N) : (inl n : N ⋊[φ] G).left = n := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | left_inl | null |
right_inl (n : N) : (inl n : N ⋊[φ] G).right = 1 := rfl | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | right_inl | null |
inl_injective : Function.Injective (inl : N → N ⋊[φ] G) :=
Function.injective_iff_hasLeftInverse.2 ⟨left, left_inl⟩
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | inl_injective | null |
inl_inj {n₁ n₂ : N} : (inl n₁ : N ⋊[φ] G) = inl n₂ ↔ n₁ = n₂ :=
inl_injective.eq_iff | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | inl_inj | null |
inr : G →* N ⋊[φ] G where
toFun g := ⟨1, g⟩
map_one' := rfl
map_mul' := by intros; ext <;> simp
@[simp] | def | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | inr | The canonical map `G →* N ⋊[φ] G` sending `g` to `⟨1, g⟩` |
left_inr (g : G) : (inr g : N ⋊[φ] G).left = 1 := rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.GroupTheory.Complement"
] | Mathlib/GroupTheory/SemidirectProduct.lean | left_inr | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.