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 ⌀ |
|---|---|---|---|---|---|---|
summandAction (i) : MulAction (M i) (Word M) where
smul m w := rcons { equivPair i w with head := m * (equivPair i w).head }
one_smul w := by
apply (equivPair i).symm_apply_eq.mpr
simp [equivPair]
mul_smul m m' w := by
dsimp [instHSMul]
simp [mul_assoc, ← equivPair_symm, Equiv.apply_symm_apply] | instance | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | summandAction | null |
smul_def {i} (m : M i) (w : Word M) :
m • w = rcons { equivPair i w with head := m * (equivPair i w).head } :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | smul_def | null |
of_smul_def (i) (w : Word M) (m : M i) :
of m • w = rcons { equivPair i w with head := m * (equivPair i w).head } :=
rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | of_smul_def | null |
equivPair_smul_same {i} (m : M i) (w : Word M) :
equivPair i (of m • w) = ⟨m * (equivPair i w).head, (equivPair i w).tail,
(equivPair i w).fstIdx_ne⟩ := by
rw [of_smul_def, ← equivPair_symm]
simp
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | equivPair_smul_same | null |
equivPair_tail {i} (p : Pair M i) :
equivPair i p.tail = ⟨1, p.tail, p.fstIdx_ne⟩ :=
equivPair_eq_of_fstIdx_ne _ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | equivPair_tail | null |
smul_eq_of_smul {i} (m : M i) (w : Word M) :
m • w = of m • w := rfl | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | smul_eq_of_smul | null |
mem_smul_iff {i j : ι} {m₁ : M i} {m₂ : M j} {w : Word M} :
⟨_, m₁⟩ ∈ (of m₂ • w).toList ↔
(¬i = j ∧ ⟨i, m₁⟩ ∈ w.toList)
∨ (m₁ ≠ 1 ∧ ∃ (hij : i = j),(⟨i, m₁⟩ ∈ w.toList.tail) ∨
(∃ m', ⟨j, m'⟩ ∈ w.toList.head? ∧ m₁ = hij ▸ (m₂ * m')) ∨
(w.fstIdx ≠ some j ∧ m₁ = hij ▸ m₂)) := by
rw [of_s... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | mem_smul_iff | null |
mem_smul_iff_of_ne {i j : ι} (hij : i ≠ j) {m₁ : M i} {m₂ : M j} {w : Word M} :
⟨_, m₁⟩ ∈ (of m₂ • w).toList ↔ ⟨i, m₁⟩ ∈ w.toList := by
simp [mem_smul_iff, *] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | mem_smul_iff_of_ne | null |
cons_eq_smul {i} {m : M i} {ls h1 h2} :
cons m ls h1 h2 = of m • ls := by
rw [of_smul_def, equivPair_eq_of_fstIdx_ne _]
· simp [cons, rcons, h2]
· exact h1 | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | cons_eq_smul | null |
rcons_eq_smul {i} (p : Pair M i) :
rcons p = of p.head • p.tail := by
simp [of_smul_def]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | rcons_eq_smul | null |
equivPair_head_smul_equivPair_tail {i : ι} (w : Word M) :
of (equivPair i w).head • (equivPair i w).tail = w := by
rw [← rcons_eq_smul, ← equivPair_symm, Equiv.symm_apply_apply] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | equivPair_head_smul_equivPair_tail | null |
equivPair_tail_eq_inv_smul {G : ι → Type*} [∀ i, Group (G i)]
[∀ i, DecidableEq (G i)] {i} (w : Word G) :
(equivPair i w).tail = (of (equivPair i w).head)⁻¹ • w :=
Eq.symm <| inv_smul_eq_iff.2 (equivPair_head_smul_equivPair_tail w).symm
@[elab_as_elim] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | equivPair_tail_eq_inv_smul | null |
smul_induction {motive : Word M → Prop} (empty : motive empty)
(smul : ∀ (i) (m : M i) (w), motive w → motive (of m • w)) (w : Word M) : motive w := by
induction w using consRecOn with
| empty => exact empty
| cons _ _ _ _ _ ih =>
rw [cons_eq_smul]
exact smul _ _ _ ih
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | smul_induction | null |
prod_smul (m) : ∀ w : Word M, prod (m • w) = m * prod w := by
induction m using CoprodI.induction_on with
| one =>
intro
rw [one_smul, one_mul]
| of _ =>
intros
rw [of_smul_def, prod_rcons, of.map_mul, mul_assoc, ← prod_rcons, ← equivPair_symm,
Equiv.symm_apply_apply]
| mul x y hx hy =>
... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | prod_smul | null |
equiv : CoprodI M ≃ Word M where
toFun m := m • empty
invFun w := prod w
left_inv m := by dsimp only; rw [prod_smul, prod_empty, mul_one]
right_inv := by
apply smul_induction
· dsimp only
rw [prod_empty, one_smul]
· dsimp only
intro i m w ih
rw [prod_smul, mul_smul, ih] | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | equiv | Each element of the free product corresponds to a unique reduced word. |
NeWord : ι → ι → Type _
| singleton : ∀ {i : ι} (x : M i), x ≠ 1 → NeWord i i
| append : ∀ {i j k l} (_w₁ : NeWord i j) (_hne : j ≠ k) (_w₂ : NeWord k l), NeWord i l | inductive | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | NeWord | A `NeWord M i j` is a representation of a non-empty reduced words where the first letter comes
from `M i` and the last letter comes from `M j`. It can be constructed from singletons and via
concatenation, and thus provides a useful induction principle. |
@[simp]
toList : ∀ {i j} (_w : NeWord M i j), List (Σ i, M i)
| i, _, singleton x _ => [⟨i, x⟩]
| _, _, append w₁ _ w₂ => w₁.toList ++ w₂.toList | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | toList | The list represented by a given `NeWord` |
toList_ne_nil {i j} (w : NeWord M i j) : w.toList ≠ List.nil := by
induction w
· rintro ⟨rfl⟩
· apply List.append_ne_nil_of_left_ne_nil
assumption | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | toList_ne_nil | null |
@[simp]
head : ∀ {i j} (_w : NeWord M i j), M i
| _, _, singleton x _ => x
| _, _, append w₁ _ _ => w₁.head | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | head | The first letter of a `NeWord` |
@[simp]
last : ∀ {i j} (_w : NeWord M i j), M j
| _, _, singleton x _hne1 => x
| _, _, append _w₁ _hne w₂ => w₂.last
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | last | The last letter of a `NeWord` |
toList_head? {i j} (w : NeWord M i j) : w.toList.head? = Option.some ⟨i, w.head⟩ := by
rw [← Option.mem_def]
induction w
· rw [Option.mem_def]
rfl
· exact List.mem_head?_append_of_mem_head? (by assumption)
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | toList_head | null |
toList_getLast? {i j} (w : NeWord M i j) : w.toList.getLast? = Option.some ⟨j, w.last⟩ := by
rw [← Option.mem_def]
induction w
· rw [Option.mem_def]
rfl
· exact List.mem_getLast?_append_of_mem_getLast? (by assumption) | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | toList_getLast | null |
toWord {i j} (w : NeWord M i j) : Word M where
toList := w.toList
ne_one := by
induction w
· simpa only [toList, List.mem_singleton, ne_eq, forall_eq]
· intro l h
simp only [toList, List.mem_append] at h
cases h <;> aesop
chain_ne := by
induction w
· exact List.isChain_singleton _
... | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | toWord | The `Word M` represented by a `NeWord M i j` |
of_word (w : Word M) (h : w ≠ empty) : ∃ (i j : _) (w' : NeWord M i j), w'.toWord = w := by
suffices ∃ (i j : _) (w' : NeWord M i j), w'.toWord.toList = w.toList by
rcases this with ⟨i, j, w, h⟩
refine ⟨i, j, w, ?_⟩
ext
rw [h]
obtain ⟨l, hnot1, hchain⟩ := w
induction l with
| nil => contradictio... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | of_word | Every nonempty `Word M` can be constructed as a `NeWord M i j` |
prod {i j} (w : NeWord M i j) :=
w.toWord.prod
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | prod | A non-empty reduced word determines an element of the free product, given by multiplication. |
singleton_head {i} (x : M i) (hne_one : x ≠ 1) : (singleton x hne_one).head = x :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | singleton_head | null |
singleton_last {i} (x : M i) (hne_one : x ≠ 1) : (singleton x hne_one).last = x :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | singleton_last | null |
prod_singleton {i} (x : M i) (hne_one : x ≠ 1) : (singleton x hne_one).prod = of x := by
simp [toWord, prod, Word.prod]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | prod_singleton | null |
append_head {i j k l} {w₁ : NeWord M i j} {hne : j ≠ k} {w₂ : NeWord M k l} :
(append w₁ hne w₂).head = w₁.head :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | append_head | null |
append_last {i j k l} {w₁ : NeWord M i j} {hne : j ≠ k} {w₂ : NeWord M k l} :
(append w₁ hne w₂).last = w₂.last :=
rfl
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | append_last | null |
append_prod {i j k l} {w₁ : NeWord M i j} {hne : j ≠ k} {w₂ : NeWord M k l} :
(append w₁ hne w₂).prod = w₁.prod * w₂.prod := by simp [toWord, prod, Word.prod] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | append_prod | null |
replaceHead : ∀ {i j : ι} (x : M i) (_hnotone : x ≠ 1) (_w : NeWord M i j), NeWord M i j
| _, _, x, h, singleton _ _ => singleton x h
| _, _, x, h, append w₁ hne w₂ => append (replaceHead x h w₁) hne w₂
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | replaceHead | One can replace the first letter in a non-empty reduced word by an element of the same
group |
replaceHead_head {i j : ι} (x : M i) (hnotone : x ≠ 1) (w : NeWord M i j) :
(replaceHead x hnotone w).head = x := by
induction w
· rfl
· simp [*, replaceHead] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | replaceHead_head | null |
mulHead {i j : ι} (w : NeWord M i j) (x : M i) (hnotone : x * w.head ≠ 1) : NeWord M i j :=
replaceHead (x * w.head) hnotone w
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | mulHead | One can multiply an element from the left to a non-empty reduced word if it does not cancel
with the first element in the word. |
mulHead_head {i j : ι} (w : NeWord M i j) (x : M i) (hnotone : x * w.head ≠ 1) :
(mulHead w x hnotone).head = x * w.head := by
induction w
· rfl
· simp [*, mulHead]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | mulHead_head | null |
mulHead_prod {i j : ι} (w : NeWord M i j) (x : M i) (hnotone : x * w.head ≠ 1) :
(mulHead w x hnotone).prod = of x * w.prod := by
unfold mulHead
induction w with
| singleton => simp [replaceHead]
| append _ _ _ w_ih_w₁ w_ih_w₂ =>
specialize w_ih_w₁ _ hnotone
simp only [replaceHead, append_prod, ← mu... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | mulHead_prod | null |
inv : ∀ {i j} (_w : NeWord G i j), NeWord G j i
| _, _, singleton x h => singleton x⁻¹ (mt inv_eq_one.mp h)
| _, _, append w₁ h w₂ => append w₂.inv h.symm w₁.inv
@[simp] | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | inv | The inverse of a non-empty reduced word |
inv_prod {i j} (w : NeWord G i j) : w.inv.prod = w.prod⁻¹ := by
induction w <;> simp [inv, *]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | inv_prod | null |
inv_head {i j} (w : NeWord G i j) : w.inv.head = w.last⁻¹ := by
induction w <;> simp [inv, *]
@[simp] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | inv_head | null |
inv_last {i j} (w : NeWord G i j) : w.inv.last = w.head⁻¹ := by
induction w <;> simp [inv, *] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | inv_last | null |
lift_word_ping_pong {i j k} (w : NeWord H i j) (hk : j ≠ k) :
lift f w.prod • X k ⊆ X i := by
induction w generalizing k with
| singleton x hne_one => simpa using hpp hk _ hne_one
| @append i j k l w₁ hne w₂ hIw₁ hIw₂ =>
calc
lift f (NeWord.append w₁ hne w₂).prod • X k = lift f w₁.prod • lift f w₂.p... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | lift_word_ping_pong | null |
lift_word_prod_nontrivial_of_other_i {i j k} (w : NeWord H i j) (hhead : k ≠ i)
(hlast : k ≠ j) : lift f w.prod ≠ 1 := by
intro heq1
have : X k ⊆ X i := by simpa [heq1] using lift_word_ping_pong f X hpp w hlast.symm
obtain ⟨x, hx⟩ := hXnonempty k
exact (hXdisj hhead).le_bot ⟨hx, this hx⟩
variable [Nontrivia... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | lift_word_prod_nontrivial_of_other_i | null |
lift_word_prod_nontrivial_of_head_eq_last {i} (w : NeWord H i i) :
lift f w.prod ≠ 1 := by
obtain ⟨k, hk⟩ := exists_ne i
exact lift_word_prod_nontrivial_of_other_i f X hXnonempty hXdisj hpp w hk hk | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | lift_word_prod_nontrivial_of_head_eq_last | null |
lift_word_prod_nontrivial_of_head_card {i j} (w : NeWord H i j)
(hcard : 3 ≤ #(H i)) (hheadtail : i ≠ j) : lift f w.prod ≠ 1 := by
obtain ⟨h, hn1, hnh⟩ := Cardinal.three_le hcard 1 w.head⁻¹
have hnot1 : h * w.head ≠ 1 := by
rw [← div_inv_eq_mul]
exact div_ne_one_of_ne hnh
let w' : NeWord H i i :=
... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | lift_word_prod_nontrivial_of_head_card | null |
lift_word_prod_nontrivial_of_not_empty {i j} (w : NeWord H i j) :
lift f w.prod ≠ 1 := by
classical
rcases hcard with hcard | hcard
· obtain ⟨i, h1, h2⟩ := Cardinal.three_le hcard i j
exact lift_word_prod_nontrivial_of_other_i f X hXnonempty hXdisj hpp w h1 h2
· obtain ⟨k, hcard⟩ := hcard
... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | lift_word_prod_nontrivial_of_not_empty | null |
empty_of_word_prod_eq_one {w : Word H} (h : lift f w.prod = 1) :
w = Word.empty := by
by_contra hnotempty
obtain ⟨i, j, w, rfl⟩ := NeWord.of_word w hnotempty
exact lift_word_prod_nontrivial_of_not_empty f hcard X hXnonempty hXdisj hpp w h
include hcard in | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | empty_of_word_prod_eq_one | null |
lift_injective_of_ping_pong : Function.Injective (lift f) := by
classical
apply (injective_iff_map_eq_one (lift f)).mpr
rw [(CoprodI.Word.equiv).forall_congr_left]
intro w Heq
dsimp [Word.equiv] at *
rw [empty_of_word_prod_eq_one f hcard X hXnonempty hXdisj hpp Heq, Word.prod_empty] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | lift_injective_of_ping_pong | The **Ping-Pong-Lemma**.
Given a group action of `G` on `X` so that the `H i` acts in a specific way on disjoint subsets
`X i` we can prove that `lift f` is injective, and thus the image of `lift f` is isomorphic to the
free product of the `H i`.
Often the Ping-Pong-Lemma is stated with regard to subgroups `H i` that... |
FreeGroupBasis.coprodI {ι : Type*} {X : ι → Type*} {G : ι → Type*} [∀ i, Group (G i)]
(B : ∀ i, FreeGroupBasis (X i) (G i)) :
FreeGroupBasis (Σ i, X i) (CoprodI G) :=
⟨MulEquiv.symm <| MonoidHom.toMulEquiv
(FreeGroup.lift fun x : Σ i, X i => CoprodI.of (B x.1 x.2))
(CoprodI.lift fun i : ι => (B i).lif... | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | FreeGroupBasis.coprodI | Given a family of free groups with distinguished bases, then their free product is free, with
a basis given by the union of the bases of the components. |
@[simps!]
_root_.freeGroupEquivCoprodI {ι : Type u_1} :
FreeGroup ι ≃* CoprodI fun _ : ι => FreeGroup Unit := by
refine MonoidHom.toMulEquiv ?_ ?_ ?_ ?_
· exact FreeGroup.lift fun i => @CoprodI.of ι _ _ i (FreeGroup.of Unit.unit)
· exact CoprodI.lift fun i => FreeGroup.lift fun _ => FreeGroup.of i
· ext; si... | def | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | _root_.freeGroupEquivCoprodI | The free product of free groups is itself a free group. -/
instance {ι : Type*} (G : ι → Type*) [∀ i, Group (G i)] [∀ i, IsFreeGroup (G i)] :
IsFreeGroup (CoprodI G) :=
(FreeGroupBasis.coprodI (fun i ↦ IsFreeGroup.basis (G i))).isFreeGroup
-- NB: One might expect this theorem to be phrased with ℤ, but ℤ is an ad... |
_root_.FreeGroup.injective_lift_of_ping_pong : Function.Injective (FreeGroup.lift a) := by
have : FreeGroup.lift a =
(CoprodI.lift fun i => FreeGroup.lift fun _ => a i).comp
(@freeGroupEquivCoprodI ι).toMonoidHom := by
ext i
simp
rw [this, MonoidHom.coe_comp]
clear this
refine Function.Inj... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Action.End",
"Mathlib.Algebra.Group.Action.Pointwise.Set.Basic",
"Mathlib.Algebra.Group.Submonoid.Membership",
"Mathlib.GroupTheory.Congruence.Basic",
"Mathlib.GroupTheory.FreeGroup.IsFreeGroup",
"Mathlib.SetTheory.Cardinal.Basic"
] | Mathlib/GroupTheory/CoprodI.lean | _root_.FreeGroup.injective_lift_of_ping_pong | The Ping-Pong-Lemma.
Given a group action of `G` on `X` so that the generators of the free groups act in specific
ways on disjoint subsets `X i` and `Y i` we can prove that `lift f` is injective, and thus the image
of `lift f` is isomorphic to the free group.
Often the Ping-Pong-Lemma is stated with regard to group e... |
@[to_additive]
exists_leftTransversal_of_FiniteIndex
{D H : Subgroup G} [D.FiniteIndex] (hD_le_H : D ≤ H) :
∃ t : Finset H,
IsComplement (t : Set H) (D.subgroupOf H) ∧
⋃ g ∈ t, (g : G) • (D : Set G) = H := by
have ⟨t, ht⟩ := (D.subgroupOf H).exists_isComplement_left 1
have hf : t.Finite := ht.... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | exists_leftTransversal_of_FiniteIndex | null |
leftCoset_cover_const_iff_surjOn :
⋃ i ∈ s, g i • (H : Set G) = Set.univ ↔ Set.SurjOn (g · : ι → G ⧸ H) s Set.univ := by
simp [Set.eq_univ_iff_forall, mem_leftCoset_iff, Set.SurjOn,
QuotientGroup.forall_mk, QuotientGroup.eq]
variable (hcovers : ⋃ i ∈ s, g i • (H : Set G) = Set.univ)
include hcovers | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | leftCoset_cover_const_iff_surjOn | null |
@[to_additive]
finiteIndex_of_leftCoset_cover_const : H.FiniteIndex := by
simp_rw [leftCoset_cover_const_iff_surjOn] at hcovers
have := Set.finite_univ_iff.mp <| Set.Finite.of_surjOn _ hcovers s.finite_toSet
exact H.finiteIndex_of_finite_quotient
@[to_additive] | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | finiteIndex_of_leftCoset_cover_const | If `H` is a subgroup of `G` and `G` is the union of a finite family of left cosets of `H`
then `H` has finite index. |
index_le_of_leftCoset_cover_const : H.index ≤ s.card := by
cases H.index.eq_zero_or_pos with
| inl h => exact h ▸ s.card.zero_le
| inr h =>
rw [leftCoset_cover_const_iff_surjOn, Set.surjOn_iff_surjective] at hcovers
exact (Nat.card_le_card_of_surjective _ hcovers).trans_eq (Nat.card_eq_finsetCard _)
@[to_... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | index_le_of_leftCoset_cover_const | null |
pairwiseDisjoint_leftCoset_cover_const_of_index_eq (hind : H.index = s.card) :
Set.PairwiseDisjoint s (g · • (H : Set G)) := by
have : Fintype (G ⧸ H) := fintypeOfIndexNeZero fun h => by
rw [hind, Finset.card_eq_zero] at h
rw [h, ← Finset.set_biUnion_coe, Finset.coe_empty, Set.biUnion_empty] at hcovers
... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | pairwiseDisjoint_leftCoset_cover_const_of_index_eq | null |
@[to_additive]
exists_finiteIndex_of_leftCoset_cover_aux [DecidableEq (Subgroup G)]
(j : ι) (hj : j ∈ s) (hcovers' : ⋃ i ∈ s.filter (H · = H j), g i • (H i : Set G) ≠ Set.univ) :
∃ i ∈ s, H i ≠ H j ∧ (H i).FiniteIndex := by
classical
have ⟨n, hn⟩ : ∃ n, n = (s.image H).card := exists_eq
induction n using ... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | exists_finiteIndex_of_leftCoset_cover_aux | null |
@[to_additive]
exists_finiteIndex_of_leftCoset_cover : ∃ k ∈ s, (H k).FiniteIndex := by
classical
have ⟨j, hj⟩ : s.Nonempty := Finset.nonempty_iff_ne_empty.mpr fun hempty => by
rw [hempty, ← Finset.set_biUnion_coe, Finset.coe_empty, Set.biUnion_empty] at hcovers
exact Set.empty_ne_univ hcovers
by_cases hc... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | exists_finiteIndex_of_leftCoset_cover | Let the group `G` be the union of finitely many left cosets `g i • H i`.
Then at least one subgroup `H i` has finite index in `G`. |
leftCoset_cover_filter_FiniteIndex_aux
[DecidablePred (FiniteIndex : Subgroup G → Prop)] :
(⋃ k ∈ s.filter (fun i => (H i).FiniteIndex), g k • (H k : Set G) = Set.univ) ∧
(1 ≤ ∑ i ∈ s, ((H i).index : ℚ)⁻¹) ∧
(∑ i ∈ s, ((H i).index : ℚ)⁻¹ = 1 → Set.PairwiseDisjoint
(s.filter (fun i => (H i).F... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | leftCoset_cover_filter_FiniteIndex_aux | null |
@[to_additive]
leftCoset_cover_filter_FiniteIndex
[DecidablePred (FiniteIndex : Subgroup G → Prop)] :
⋃ k ∈ s.filter (fun i => (H i).FiniteIndex), g k • (H k : Set G) = Set.univ :=
(leftCoset_cover_filter_FiniteIndex_aux hcovers).1 | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | leftCoset_cover_filter_FiniteIndex | Let the group `G` be the union of finitely many left cosets `g i • H i`.
Then the cosets of subgroups of infinite index may be omitted from the covering. |
@[to_additive one_le_sum_inv_index_of_leftCoset_cover]
one_le_sum_inv_index_of_leftCoset_cover :
1 ≤ ∑ i ∈ s, ((H i).index : ℚ)⁻¹ :=
have := Classical.decPred (FiniteIndex : Subgroup G → Prop)
(leftCoset_cover_filter_FiniteIndex_aux hcovers).2.1 | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | one_le_sum_inv_index_of_leftCoset_cover | Let the group `G` be the union of finitely many left cosets `g i • H i`. Then the
sum of the inverses of the indexes of the subgroups `H i` is greater than or equal to 1. |
@[to_additive]
pairwiseDisjoint_leftCoset_cover_of_sum_inv_index_eq_one
[DecidablePred (FiniteIndex : Subgroup G → Prop)] :
∑ i ∈ s, ((H i).index : ℚ)⁻¹ = 1 →
Set.PairwiseDisjoint (s.filter (fun i => (H i).FiniteIndex))
(fun i ↦ g i • (H i : Set G)) :=
(leftCoset_cover_filter_FiniteIndex_aux hco... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | pairwiseDisjoint_leftCoset_cover_of_sum_inv_index_eq_one | Let the group `G` be the union of finitely many left cosets `g i • H i`.
If the sum of the inverses of the indexes of the subgroups `H i` is equal to 1,
then the cosets of the subgroups of finite index are pairwise disjoint. |
@[to_additive]
exists_index_le_card_of_leftCoset_cover :
∃ i ∈ s, (H i).FiniteIndex ∧ (H i).index ≤ s.card := by
by_contra! h
apply (one_le_sum_inv_index_of_leftCoset_cover hcovers).not_gt
cases s.eq_empty_or_nonempty with
| inl hs => simp only [hs, Finset.sum_empty, zero_lt_one]
| inr hs =>
have hs' : ... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | exists_index_le_card_of_leftCoset_cover | B. H. Neumann Lemma :
If a finite family of cosets of subgroups covers the group, then at least one
of these subgroups has index not exceeding the number of cosets. |
Submodule.exists_finiteIndex_of_cover (hcovers : ⋃ i ∈ s, (p i : Set M) = Set.univ) :
∃ k ∈ s, (p k).toAddSubgroup.FiniteIndex :=
have hcovers' : ⋃ i ∈ s, (0 : M) +ᵥ ((p i).toAddSubgroup : Set M) = Set.univ := by
simpa only [zero_vadd] using hcovers
AddSubgroup.exists_finiteIndex_of_leftCoset_cover hcovers' | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | Submodule.exists_finiteIndex_of_cover | null |
Subspace.biUnion_ne_univ_of_top_notMem (hs : ⊤ ∉ s) :
⋃ p ∈ s, (p : Set E) ≠ Set.univ := by
intro hcovers
have ⟨p, hp, hfi⟩ := Submodule.exists_finiteIndex_of_cover hcovers
have : Finite (E ⧸ p) := AddSubgroup.finite_quotient_of_finiteIndex
have : Nontrivial (E ⧸ p) :=
Submodule.Quotient.nontrivial_of_l... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | Subspace.biUnion_ne_univ_of_top_notMem | null |
Subspace.top_mem_of_biUnion_eq_univ (hcovers : ⋃ p ∈ s, (p : Set E) = Set.univ) :
⊤ ∈ s := by
contrapose! hcovers
exact Subspace.biUnion_ne_univ_of_top_notMem hcovers | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | Subspace.top_mem_of_biUnion_eq_univ | null |
Subspace.exists_eq_top_of_iUnion_eq_univ {ι} [Finite ι] {p : ι → Subspace k E}
(hcovers : ⋃ i, (p i : Set E) = Set.univ) : ∃ i, p i = ⊤ := by
have := Fintype.ofFinite (Set.range p)
simp_rw [← Set.biUnion_range (f := p), ← Set.mem_toFinset] at hcovers
apply Set.mem_toFinset.mp (Subspace.top_mem_of_biUnion_eq_u... | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Ring.Rat",
"Mathlib.GroupTheory.Complement",
"Mathlib.LinearAlgebra.Basis.VectorSpace"
] | Mathlib/GroupTheory/CosetCover.lean | Subspace.exists_eq_top_of_iUnion_eq_univ | null |
DivisibleBy where
/-- The division function -/
div : A → α → A
div_zero : ∀ a, div a 0 = 0
div_cancel : ∀ {n : α} (a : A), n ≠ 0 → n • div a n = a | class | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | DivisibleBy | An `AddMonoid A` is `α`-divisible iff `n • x = a` has a solution for all `n ≠ 0 ∈ α` and `a ∈ A`.
Here we adopt a constructive approach where we ask an explicit `div : A → α → A` function such that
* `div a 0 = 0` for all `a ∈ A`
* `n • div a n = a` for all `n ≠ 0 ∈ α` and `a ∈ A`. |
@[to_additive]
RootableBy where
/-- The root function -/
root : A → α → A
root_zero : ∀ a, root a 0 = 1
root_cancel : ∀ {n : α} (a : A), n ≠ 0 → root a n ^ n = a
@[to_additive smul_right_surj_of_divisibleBy] | class | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | RootableBy | A `Monoid A` is `α`-rootable iff `xⁿ = a` has a solution for all `n ≠ 0 ∈ α` and `a ∈ A`.
Here we adopt a constructive approach where we ask an explicit `root : A → α → A` function such that
* `root a 0 = 1` for all `a ∈ A`
* `(root a n)ⁿ = a` for all `n ≠ 0 ∈ α` and `a ∈ A`. |
pow_left_surj_of_rootableBy [RootableBy A α] {n : α} (hn : n ≠ 0) :
Function.Surjective (fun a => a ^ n : A → A) := fun x =>
⟨RootableBy.root x n, RootableBy.root_cancel _ hn⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | pow_left_surj_of_rootableBy | null |
@[to_additive divisibleByOfSMulRightSurj /-- An `AddMonoid A` is `α`-divisible iff `n • _` is a
surjective function, i.e. the constructive version implies the textbook approach. -/]
noncomputable rootableByOfPowLeftSurj
(H : ∀ {n : α}, n ≠ 0 → Function.Surjective (fun a => a ^ n : A → A)) : RootableBy A α where
r... | def | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | rootableByOfPowLeftSurj | A `Monoid A` is `α`-rootable iff the `pow _ n` function is surjective, i.e. the constructive version
implies the textbook approach. |
@[to_additive]
Pi.rootableBy : RootableBy (∀ i, B i) β where
root x n i := RootableBy.root (x i) n
root_zero _x := funext fun _i => RootableBy.root_zero _
root_cancel _x hn := funext fun _i => RootableBy.root_cancel _ hn | instance | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | Pi.rootableBy | null |
@[to_additive]
Prod.rootableBy : RootableBy (B × B') β where
root p n := (RootableBy.root p.1 n, RootableBy.root p.2 n)
root_zero _p := Prod.ext (RootableBy.root_zero _) (RootableBy.root_zero _)
root_cancel _p hn := Prod.ext (RootableBy.root_cancel _ hn) (RootableBy.root_cancel _ hn) | instance | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | Prod.rootableBy | null |
@[to_additive]
ULift.instRootableBy [RootableBy A α] : RootableBy (ULift A) α where
root x a := ULift.up <| RootableBy.root x.down a
root_zero x := ULift.ext _ _ <| RootableBy.root_zero x.down
root_cancel _ h := ULift.ext _ _ <| RootableBy.root_cancel _ h | instance | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | ULift.instRootableBy | null |
smul_top_eq_top_of_divisibleBy_int [DivisibleBy A ℤ] {n : ℤ} (hn : n ≠ 0) :
n • (⊤ : AddSubgroup A) = ⊤ :=
AddSubgroup.map_top_of_surjective _ fun a => ⟨DivisibleBy.div a n, DivisibleBy.div_cancel _ hn⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | smul_top_eq_top_of_divisibleBy_int | null |
noncomputable divisibleByIntOfSMulTopEqTop
(H : ∀ {n : ℤ} (_hn : n ≠ 0), n • (⊤ : AddSubgroup A) = ⊤) : DivisibleBy A ℤ where
div a n :=
if hn : n = 0 then 0 else (show a ∈ n • (⊤ : AddSubgroup A) by rw [H hn]; trivial).choose
div_zero _ := dif_pos rfl
div_cancel a hn := by
simp_rw [dif_neg hn]
ge... | def | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | divisibleByIntOfSMulTopEqTop | If for all `n ≠ 0 ∈ ℤ`, `n • A = A`, then `A` is divisible. |
@[to_additive /-- An additive group is `ℤ`-divisible if it is `ℕ`-divisible. -/]
rootableByIntOfRootableByNat [RootableBy A ℕ] : RootableBy A ℤ where
root a z :=
match z with
| (n : ℕ) => RootableBy.root a n
| -[n+1] => (RootableBy.root a (n + 1))⁻¹
root_zero a := RootableBy.root_zero a
root_cancel {n... | def | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | rootableByIntOfRootableByNat | A group is `ℤ`-rootable if it is `ℕ`-rootable. |
@[to_additive /-- An additive group is `ℕ`-divisible if it `ℤ`-divisible. -/]
rootableByNatOfRootableByInt [RootableBy A ℤ] : RootableBy A ℕ where
root a n := RootableBy.root a (n : ℤ)
root_zero a := RootableBy.root_zero a
root_cancel {n} a hn := by
have := RootableBy.root_cancel a (show (n : ℤ) ≠ 0 from mod_... | def | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | rootableByNatOfRootableByInt | A group is `ℕ`-rootable if it is `ℤ`-rootable |
@[to_additive
/-- If `f : A → B` is a surjective homomorphism and `A` is `α`-divisible, then `B` is also
`α`-divisible. -/]
noncomputable Function.Surjective.rootableBy (hf : Function.Surjective f)
(hpow : ∀ (a : A) (n : α), f (a ^ n) = f a ^ n) : RootableBy B α :=
rootableByOfPowLeftSurj _ _ fun {n} ... | def | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | Function.Surjective.rootableBy | If `f : A → B` is a surjective homomorphism and `A` is `α`-rootable, then `B` is also `α`-rootable. |
RootableBy.surjective_pow (A α : Type*) [Monoid A] [Pow A α] [Zero α] [RootableBy A α]
{n : α} (hn : n ≠ 0) : Function.Surjective fun a : A => a ^ n := fun a =>
⟨RootableBy.root a n, RootableBy.root_cancel a hn⟩ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | RootableBy.surjective_pow | null |
@[to_additive /-- Any quotient group of a divisible group is divisible -/]
noncomputable QuotientGroup.rootableBy [RootableBy A ℕ] : RootableBy (A ⧸ B) ℕ :=
QuotientGroup.mk_surjective.rootableBy _ fun _ _ => rfl | instance | GroupTheory | [
"Mathlib.Algebra.Group.ULift",
"Mathlib.Algebra.GroupWithZero.Subgroup",
"Mathlib.Algebra.Module.NatInt",
"Mathlib.GroupTheory.QuotientGroup.Defs",
"Mathlib.Tactic.NormNum.Eq"
] | Mathlib/GroupTheory/Divisible.lean | QuotientGroup.rootableBy | Any quotient group of a rootable group is rootable. |
doubleCoset (a : α) (s t : Set α) : Set α :=
s * {a} * t
@[deprecated (since := "2025-07-12")] alias _root_.Doset.doset := doubleCoset | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | doubleCoset | The double coset as an element of `Set α` corresponding to `s a t` |
doubleCoset_eq_image2 (a : α) (s t : Set α) :
doubleCoset a s t = Set.image2 (· * a * ·) s t := by
simp_rw [doubleCoset, Set.mul_singleton, ← Set.image2_mul, Set.image2_image_left]
@[deprecated (since := "2025-07-12")] alias _root_.Doset.doset_eq_image2 := doubleCoset_eq_image2 | lemma | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | doubleCoset_eq_image2 | null |
mem_doubleCoset {s t : Set α} {a b : α} :
b ∈ doubleCoset a s t ↔ ∃ x ∈ s, ∃ y ∈ t, b = x * a * y := by
simp only [doubleCoset_eq_image2, Set.mem_image2, eq_comm]
@[deprecated (since := "2025-07-12")] alias _root_.Doset.mem_doset := mem_doubleCoset | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | mem_doubleCoset | null |
mem_doubleCoset_self (H K : Subgroup G) (a : G) : a ∈ doubleCoset a H K :=
mem_doubleCoset.mpr ⟨1, H.one_mem, 1, K.one_mem, (one_mul a).symm.trans (mul_one (1 * a)).symm⟩
@[deprecated (since := "2025-07-12")] alias _root_.Doset.mem_doset_self := mem_doubleCoset_self | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | mem_doubleCoset_self | null |
doubleCoset_eq_of_mem {H K : Subgroup G} {a b : G} (hb : b ∈ doubleCoset a H K) :
doubleCoset b H K = doubleCoset a H K := by
obtain ⟨h, hh, k, hk, rfl⟩ := mem_doubleCoset.1 hb
rw [doubleCoset, doubleCoset, ← Set.singleton_mul_singleton, ← Set.singleton_mul_singleton,
mul_assoc, mul_assoc, Subgroup.singleto... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | doubleCoset_eq_of_mem | null |
mem_doubleCoset_of_not_disjoint {H K : Subgroup G} {a b : G}
(h : ¬Disjoint (doubleCoset a H K) (doubleCoset b H K)) : b ∈ doubleCoset a H K := by
rw [Set.not_disjoint_iff] at h
simp only [mem_doubleCoset] at *
obtain ⟨x, ⟨l, hl, r, hr, hrx⟩, y, hy, ⟨r', hr', rfl⟩⟩ := h
refine ⟨y⁻¹ * l, H.mul_mem (H.inv_mem... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | mem_doubleCoset_of_not_disjoint | null |
eq_of_not_disjoint {H K : Subgroup G} {a b : G}
(h : ¬Disjoint (doubleCoset a H K) (doubleCoset b H K)) :
doubleCoset a H K = doubleCoset b H K := by
rw [disjoint_comm] at h
have ha : a ∈ doubleCoset b H K := mem_doubleCoset_of_not_disjoint h
apply doubleCoset_eq_of_mem ha
@[deprecated (since := "2025-07-... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | eq_of_not_disjoint | null |
setoid (H K : Set G) : Setoid G :=
Setoid.ker fun x => doubleCoset x H K
@[deprecated (since := "2025-07-12")]
alias _root_.Doset.setoid := setoid | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | setoid | The setoid defined by the double_coset relation |
Quotient (H K : Set G) : Type _ :=
_root_.Quotient (setoid H K)
@[deprecated (since := "2025-07-12")]
alias _root_.Doset.Quotient := Quotient | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | Quotient | Quotient of `G` by the double coset relation, i.e. `H \ G / K` |
rel_iff {H K : Subgroup G} {x y : G} :
setoid ↑H ↑K x y ↔ ∃ a ∈ H, ∃ b ∈ K, y = a * x * b :=
Iff.trans
⟨fun (hxy : doubleCoset x H K = doubleCoset y H K) => hxy ▸ mem_doubleCoset_self H K y,
fun hxy => (doubleCoset_eq_of_mem hxy).symm⟩ mem_doubleCoset
@[deprecated (since := "2025-07-12")]
alias _root_.D... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | rel_iff | null |
bot_rel_eq_leftRel (H : Subgroup G) :
⇑(setoid ↑(⊥ : Subgroup G) ↑H) = ⇑(QuotientGroup.leftRel H) := by
ext a b
rw [rel_iff, QuotientGroup.leftRel_apply]
constructor
· rintro ⟨a, rfl : a = 1, b, hb, rfl⟩
rwa [one_mul, inv_mul_cancel_left]
· rintro (h : a⁻¹ * b ∈ H)
exact ⟨1, rfl, a⁻¹ * b, h, by rw... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | bot_rel_eq_leftRel | null |
rel_bot_eq_right_group_rel (H : Subgroup G) :
⇑(setoid ↑H ↑(⊥ : Subgroup G)) = ⇑(QuotientGroup.rightRel H) := by
ext a b
rw [rel_iff, QuotientGroup.rightRel_apply]
constructor
· rintro ⟨b, hb, a, rfl : a = 1, rfl⟩
rwa [mul_one, mul_inv_cancel_right]
· rintro (h : b * a⁻¹ ∈ H)
exact ⟨b * a⁻¹, h, 1,... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | rel_bot_eq_right_group_rel | null |
quotToDoubleCoset (H K : Subgroup G) (q : Quotient (H : Set G) K) : Set G :=
doubleCoset q.out H K
@[deprecated (since := "2025-07-12")] alias _root_.Doset.quotToDoset := quotToDoubleCoset | def | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | quotToDoubleCoset | Create a double coset out of an element of `H \ G / K` |
mk (H K : Subgroup G) (a : G) : Quotient (H : Set G) K :=
Quotient.mk'' a
@[deprecated (since := "2025-07-12")] alias _root_.Doset.mk := mk | abbrev | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | mk | Map from `G` to `H \ G / K` |
eq (H K : Subgroup G) (a b : G) :
mk H K a = mk H K b ↔ ∃ h ∈ H, ∃ k ∈ K, b = h * a * k := by
rw [Quotient.eq'']
apply rel_iff
@[deprecated (since := "2025-07-12")] alias _root_.Doset.eq := eq | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | eq | null |
out_eq' (H K : Subgroup G) (q : Quotient ↑H ↑K) : mk H K q.out = q :=
Quotient.out_eq' q
@[deprecated (since := "2025-07-12")] alias _root_.Doset.out_eq' := out_eq' | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | out_eq' | null |
mk_out_eq_mul (H K : Subgroup G) (g : G) :
∃ h k : G, h ∈ H ∧ k ∈ K ∧ (mk H K g : Quotient ↑H ↑K).out = h * g * k := by
have := eq H K (mk H K g : Quotient ↑H ↑K).out g
rw [out_eq'] at this
obtain ⟨h, h_h, k, hk, T⟩ := this.1 rfl
refine ⟨h⁻¹, k⁻¹, H.inv_mem h_h, K.inv_mem hk, eq_mul_inv_of_mul_eq (eq_inv_mu... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | mk_out_eq_mul | null |
mk_eq_of_doubleCoset_eq {H K : Subgroup G} {a b : G}
(h : doubleCoset a H K = doubleCoset b H K) : mk H K a = mk H K b := by
rw [eq]
exact mem_doubleCoset.mp (h.symm ▸ mem_doubleCoset_self H K b)
@[deprecated (since := "2025-07-12")]
alias _root_.Doset.mk_eq_of_doset_eq := mk_eq_of_doubleCoset_eq | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | mk_eq_of_doubleCoset_eq | null |
disjoint_out {H K : Subgroup G} {a b : Quotient H K} :
a ≠ b → Disjoint (doubleCoset a.out H K) (doubleCoset b.out (H : Set G) K) := by
contrapose!
intro h
simpa [out_eq'] using mk_eq_of_doubleCoset_eq (eq_of_not_disjoint h)
@[deprecated (since := "2025-07-12")] alias _root_.Doset.disjoint_out := disjoint_out | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | disjoint_out | null |
union_quotToDoubleCoset (H K : Subgroup G) : ⋃ q, quotToDoubleCoset H K q = Set.univ := by
ext x
simp only [Set.mem_iUnion, quotToDoubleCoset, mem_doubleCoset, SetLike.mem_coe, Set.mem_univ,
iff_true]
use mk H K x
obtain ⟨h, k, h3, h4, h5⟩ := mk_out_eq_mul H K x
refine ⟨h⁻¹, H.inv_mem h3, k⁻¹, K.inv_mem h... | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Pointwise",
"Mathlib.GroupTheory.Coset.Basic"
] | Mathlib/GroupTheory/DoubleCoset.lean | union_quotToDoubleCoset | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.