File: Mathlib/GroupTheory/Coxeter/Basic.lean

full_name: CoxeterMatrix.relation
code: /-- The Coxeter relation associated to a Coxeter matrix $M$ and two indices $i, i' \in B$.
That is, the relation $(s_i s_{i'})^{M_{i, i'}}$, considered as an element of the free group
on $\{s_i\}_{i \in B}$.
If $M_{i, i'} = 0$, then this is the identity, indicating that there is no relation between
$s_i$ and $s_{i'}$. -/
def relation (i i' : B) : FreeGroup B 
goal: FreeGroup B

full_name: CoxeterMatrix.relationsSet
code: /-- The set of all Coxeter relations associated to the Coxeter matrix $M$. -/
def relationsSet : Set (FreeGroup B) 
goal: Set (FreeGroup B)

full_name: CoxeterMatrix.Group
code: /-- The Coxeter group associated to a Coxeter matrix $M$; that is, the group
$$\langle \{s_i\}_{i \in B} \vert \{(s_i s_{i'})^{M_{i, i'}}\}_{i, i' \in B} \rangle.$$ -/
protected def Group : Type _ 
goal: Type u_1

full_name: CoxeterMatrix.instGroupGroup
code: instance : Group M.Group 
goal: Group M.Group

full_name: CoxeterMatrix.simple
code: /-- The simple reflection of the Coxeter group `M.group` at the index `i`. -/
def simple (i : B) : M.Group 
goal: M.Group

full_name: CoxeterMatrix.reindex_relationsSet
code: theorem reindex_relationsSet :
    (M.reindex e).relationsSet =
    FreeGroup.freeGroupCongr e '' M.relationsSet 
goal: (CoxeterMatrix.reindex e M).relationsSet = ⇑(FreeGroup.freeGroupCongr e) '' M.relationsSet

full_name: CoxeterMatrix.reindexGroupEquiv
code: /-- The isomorphism between the Coxeter group associated to the reindexed matrix `M.reindex e` and
the Coxeter group associated to `M`. -/
def reindexGroupEquiv : (M.reindex e).Group ≃* M.Group 
goal: (CoxeterMatrix.reindex e M).Group ≃* M.Group

full_name: CoxeterMatrix.reindexGroupEquiv_apply_simple
code: theorem reindexGroupEquiv_apply_simple (i : B') :
    (M.reindexGroupEquiv e) ((M.reindex e).simple i) = M.simple (e.symm i) 
goal: (M.reindexGroupEquiv e) ((CoxeterMatrix.reindex e M).simple i) = M.simple (e.symm i)

full_name: CoxeterMatrix.reindexGroupEquiv_symm_apply_simple
code: theorem reindexGroupEquiv_symm_apply_simple (i : B) :
    (M.reindexGroupEquiv e).symm (M.simple i) = (M.reindex e).simple (e i) 
goal: (M.reindexGroupEquiv e).symm (M.simple i) = (CoxeterMatrix.reindex e M).simple (e i)

full_name: CoxeterSystem.mulEquiv
code: /-- A Coxeter system `CoxeterSystem M W` is a structure recording the isomorphism between
a group `W` and the Coxeter group associated to a Coxeter matrix `M`. -/
@[ext]
structure CoxeterSystem (W : Type*) [Group W] where
  /-- The isomorphism between `W` and the Coxeter group associated to `M`. -/
  mulEquiv : W ≃* M.Group
goal: W ≃* M.Group

full_name: CoxeterSystem
code: /-- A Coxeter system `CoxeterSystem M W` is a structure recording the isomorphism between
a group `W` and the Coxeter group associated to a Coxeter matrix `M`. -/
@[ext]
structure CoxeterSystem (W : Type*) [Group W] where
  /-- The isomorphism between `W` and the Coxeter group associated to `M`. -/
  mulEquiv : W ≃* M.Group
goal: Type (max u_1 u_2)

full_name: IsCoxeterGroup.nonempty_system
code: /-- A group is a Coxeter group if it admits a Coxeter system for some Coxeter matrix `M`. -/
class IsCoxeterGroup.{u} (W : Type u) [Group W] : Prop where
  nonempty_system : ∃ B : Type u, ∃ M : CoxeterMatrix B, Nonempty (CoxeterSystem M W)
goal: ∃ B M, Nonempty (CoxeterSystem M W)

full_name: CoxeterMatrix.toCoxeterSystem
code: /-- The canonical Coxeter system on the Coxeter group associated to `M`. -/
def CoxeterMatrix.toCoxeterSystem : CoxeterSystem M M.Group 
goal: CoxeterSystem M M.Group

full_name: CoxeterSystem.reindex_mulEquiv
code: /-- Reindex a Coxeter system through a bijection of the indexing sets. -/
@[simps]
protected def reindex (e : B ≃ B') : CoxeterSystem (M.reindex e) W 
goal: (cs.reindex e).mulEquiv = cs.mulEquiv.trans (M.reindexGroupEquiv e).symm

full_name: CoxeterSystem.reindex
code: /-- Reindex a Coxeter system through a bijection of the indexing sets. -/
@[simps]
protected def reindex (e : B ≃ B') : CoxeterSystem (M.reindex e) W 
goal: CoxeterSystem (CoxeterMatrix.reindex e M) W

full_name: CoxeterSystem.map_mulEquiv
code: /-- Push a Coxeter system through a group isomorphism. -/
@[simps]
protected def map (e : W ≃* H) : CoxeterSystem M H 
goal: (cs.map e).mulEquiv = e.symm.trans cs.mulEquiv

full_name: CoxeterSystem.map
code: /-- Push a Coxeter system through a group isomorphism. -/
@[simps]
protected def map (e : W ≃* H) : CoxeterSystem M H 
goal: CoxeterSystem M H

full_name: CoxeterSystem.simple
code: /-- The simple reflection of `W` at the index `i`. -/
def simple (i : B) : W 
goal: W

full_name: CoxeterMatrix.toCoxeterSystem_simple
code: @[simp]
theorem _root_.CoxeterMatrix.toCoxeterSystem_simple (M : CoxeterMatrix B) :
    M.toCoxeterSystem.simple = M.simple 
goal: M.toCoxeterSystem.simple = M.simple

full_name: CoxeterSystem.reindex_simple
code: @[simp] theorem reindex_simple (i' : B') : (cs.reindex e).simple i' = cs.simple (e.symm i') 
goal: (cs.reindex e).simple i' = cs.simple (e.symm i')

full_name: CoxeterSystem.map_simple
code: @[simp] theorem map_simple (e : W ≃* H) (i : B) : (cs.map e).simple i = e (cs.simple i) 
goal: (cs.map e).simple i = e (cs.simple i)

full_name: CoxeterSystem._aux_Mathlib_GroupTheory_Coxeter_Basic___macroRules_CoxeterSystem_termS__1
code: local prefix:100 "s" => cs.simple
goal: Lean.Macro

full_name: CoxeterSystem.simple_mul_simple_self
code: @[simp]
theorem simple_mul_simple_self (i : B) : s i * s i = 1 
goal: cs.simple i * cs.simple i = 1

full_name: CoxeterSystem.simple_mul_simple_cancel_right
code: @[simp]
theorem simple_mul_simple_cancel_right {w : W} (i : B) : w * s i * s i = w 
goal: w * cs.simple i * cs.simple i = w

full_name: CoxeterSystem.simple_mul_simple_cancel_left
code: @[simp]
theorem simple_mul_simple_cancel_left {w : W} (i : B) : s i * (s i * w) = w 
goal: cs.simple i * (cs.simple i * w) = w

full_name: CoxeterSystem.simple_sq
code: @[simp] theorem simple_sq (i : B) : s i ^ 2 = 1 
goal: cs.simple i ^ 2 = 1

full_name: CoxeterSystem.inv_simple
code: @[simp]
theorem inv_simple (i : B) : (s i)⁻¹ = s i 
goal: (cs.simple i)⁻¹ = cs.simple i

full_name: CoxeterSystem.simple_mul_simple_pow
code: @[simp]
theorem simple_mul_simple_pow (i i' : B) : (s i * s i') ^ M i i' = 1 
goal: (cs.simple i * cs.simple i') ^ M.M i i' = 1

full_name: CoxeterSystem.simple_mul_simple_pow'
code: @[simp] theorem simple_mul_simple_pow' (i i' : B) : (s i' * s i) ^ M i i' = 1 
goal: (cs.simple i' * cs.simple i) ^ M.M i i' = 1

full_name: CoxeterSystem.subgroup_closure_range_simple
code: /-- The simple reflections of `W` generate `W` as a group. -/
theorem subgroup_closure_range_simple : Subgroup.closure (range cs.simple) = ⊤ 
goal: Subgroup.closure (Set.range cs.simple) = ⊤

full_name: CoxeterSystem.submonoid_closure_range_simple
code: /-- The simple reflections of `W` generate `W` as a monoid. -/
theorem submonoid_closure_range_simple : Submonoid.closure (range cs.simple) = ⊤ 
goal: Submonoid.closure (Set.range cs.simple) = ⊤

full_name: CoxeterSystem.simple_induction
code: /-- If `p : W → Prop` holds for all simple reflections, it holds for the identity, and it is
preserved under multiplication, then it holds for all elements of `W`. -/
theorem simple_induction {p : W → Prop} (w : W) (simple : ∀ i : B, p (s i)) (one : p 1)
    (mul : ∀ w w' : W, p w → p w' → p (w * w')) : p w 
goal: p w

full_name: CoxeterSystem.simple_induction_left
code: /-- If `p : W → Prop` holds for the identity and it is preserved under multiplying on the left
by a simple reflection, then it holds for all elements of `W`. -/
theorem simple_induction_left {p : W → Prop} (w : W) (one : p 1)
    (mul_simple_left : ∀ (w : W) (i : B), p w → p (s i * w)) : p w 
goal: p w

full_name: CoxeterSystem.simple_induction_right
code: /-- If `p : W → Prop` holds for the identity and it is preserved under multiplying on the right
by a simple reflection, then it holds for all elements of `W`. -/
theorem simple_induction_right {p : W → Prop} (w : W) (one : p 1)
    (mul_simple_right : ∀ (w : W) (i : B), p w → p (w * s i)) : p w 
goal: p w

full_name: CoxeterSystem.ext_simple
code: /-- If two homomorphisms with domain `W` agree on all simple reflections, then they are equal. -/
theorem ext_simple {G : Type*} [Monoid G] {φ₁ φ₂ : W →* G} (h : ∀ i : B, φ₁ (s i) = φ₂ (s i)) :
    φ₁ = φ₂ 
goal: φ₁ = φ₂

full_name: CoxeterMatrix.IsLiftable
code: /-- The proposition that the values of the function `f : B → G` satisfy the Coxeter relations
corresponding to the matrix `M`. -/
def _root_.CoxeterMatrix.IsLiftable {G : Type*} [Monoid G] (M : CoxeterMatrix B) (f : B → G) :
    Prop 
goal: Prop

full_name: _private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.relations_liftable
code: private theorem relations_liftable {G : Type*} [Group G] {f : B → G} (hf : IsLiftable M f)
    (r : FreeGroup B) (hr : r ∈ M.relationsSet) : (FreeGroup.lift f) r = 1 
goal: (FreeGroup.lift f) r = 1

full_name: _private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.groupLift
code: private def groupLift {G : Type*} [Group G] {f : B → G} (hf : IsLiftable M f) : W →* G 
goal: W →* G

full_name: _private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.restrictUnit
code: private def restrictUnit {G : Type*} [Monoid G] {f : B → G} (hf : IsLiftable M f) (i : B) :
    Gˣ 
goal: Gˣ

full_name: _private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.toMonoidHom_apply_symm_apply
code: private theorem toMonoidHom_apply_symm_apply (a : PresentedGroup (M.relationsSet)) :
    (MulEquiv.toMonoidHom cs.mulEquiv : W →* PresentedGroup (M.relationsSet))
    ((MulEquiv.symm cs.mulEquiv) a) = a 
goal: cs.mulEquiv.toMonoidHom (cs.mulEquiv.symm a) = a

full_name: CoxeterSystem.lift
code: /-- The universal mapping property of Coxeter systems. For any monoid `G`,
functions `f : B → G` whose values satisfy the Coxeter relations are equivalent to
monoid homomorphisms `f' : W → G`. -/
def lift {G : Type*} [Monoid G] : {f : B → G // IsLiftable M f} ≃ (W →* G) 
goal: { f // M.IsLiftable f } ≃ (W →* G)

full_name: CoxeterSystem.lift_apply_simple
code: @[simp]
theorem lift_apply_simple {G : Type*} [Monoid G] {f : B → G} (hf : IsLiftable M f) (i : B) :
    cs.lift ⟨f, hf⟩ (s i) = f i 
goal: (cs.lift ⟨f, hf⟩) (cs.simple i) = f i

full_name: CoxeterSystem.simple_determines_coxeterSystem
code: /-- If two Coxeter systems on the same group `W` have the same Coxeter matrix `M : Matrix B B ℕ`
and the same simple reflection map `B → W`, then they are identical. -/
theorem simple_determines_coxeterSystem :
    Injective (simple : CoxeterSystem M W → B → W) 
goal: Function.Injective CoxeterSystem.simple

full_name: CoxeterSystem.wordProd
code: /-- The product of the simple reflections of `W` corresponding to the indices in `ω`. -/
def wordProd (ω : List B) : W 
goal: W

full_name: CoxeterSystem._aux_Mathlib_GroupTheory_Coxeter_Basic___macroRules_CoxeterSystem_termπ__1
code: local prefix:100 "π" => cs.wordProd
goal: Lean.Macro

full_name: CoxeterSystem.wordProd_nil
code: @[simp] theorem wordProd_nil : π [] = 1 
goal: cs.wordProd [] = 1

full_name: CoxeterSystem.wordProd_cons
code: theorem wordProd_cons (i : B) (ω : List B) : π (i :: ω) = s i * π ω 
goal: cs.wordProd (i :: ω) = cs.simple i * cs.wordProd ω

full_name: CoxeterSystem.wordProd_singleton
code: @[simp] theorem wordProd_singleton (i : B) : π ([i]) = s i 
goal: cs.wordProd [i] = cs.simple i

full_name: CoxeterSystem.wordProd_concat
code: theorem wordProd_concat (i : B) (ω : List B) : π (ω.concat i) = π ω * s i 
goal: cs.wordProd (ω.concat i) = cs.wordProd ω * cs.simple i

full_name: CoxeterSystem.wordProd_append
code: theorem wordProd_append (ω ω' : List B) : π (ω ++ ω') = π ω * π ω' 
goal: cs.wordProd (ω ++ ω') = cs.wordProd ω * cs.wordProd ω'

full_name: CoxeterSystem.wordProd_reverse
code: @[simp] theorem wordProd_reverse (ω : List B) : π (reverse ω) = (π ω)⁻¹ 
goal: cs.wordProd ω.reverse = (cs.wordProd ω)⁻¹

full_name: CoxeterSystem.wordProd_surjective
code: theorem wordProd_surjective : Surjective cs.wordProd 
goal: Function.Surjective cs.wordProd

full_name: CoxeterSystem.alternatingWord
code: /-- The word of length `m` that alternates between `i` and `i'`, ending with `i'`. -/
def alternatingWord (i i' : B) (m : ℕ) : List B 
goal: List B

full_name: CoxeterSystem.braidWord
code: /-- The word of length `M i i'` that alternates between `i` and `i'`, ending with `i'`. -/
abbrev braidWord (M : CoxeterMatrix B) (i i' : B) : List B 
goal: List B

full_name: CoxeterSystem.alternatingWord_succ
code: theorem alternatingWord_succ (i i' : B) (m : ℕ) :
    alternatingWord i i' (m + 1) = (alternatingWord i' i m).concat i' 
goal: CoxeterSystem.alternatingWord i i' (m + 1) = (CoxeterSystem.alternatingWord i' i m).concat i'

full_name: CoxeterSystem.alternatingWord_succ'
code: theorem alternatingWord_succ' (i i' : B) (m : ℕ) :
    alternatingWord i i' (m + 1) = (if Even m then i' else i) :: alternatingWord i i' m 
goal: CoxeterSystem.alternatingWord i i' (m + 1) = (if Even m then i' else i) :: CoxeterSystem.alternatingWord i i' m

full_name: CoxeterSystem.length_alternatingWord
code: @[simp]
theorem length_alternatingWord (i i' : B) (m : ℕ) :
    List.length (alternatingWord i i' m) = m 
goal: (CoxeterSystem.alternatingWord i i' m).length = m

full_name: CoxeterSystem.prod_alternatingWord_eq_mul_pow
code: theorem prod_alternatingWord_eq_mul_pow (i i' : B) (m : ℕ) :
    π (alternatingWord i i' m) = (if Even m then 1 else s i') * (s i * s i') ^ (m / 2) 
goal: cs.wordProd (CoxeterSystem.alternatingWord i i' m) =
  (if Even m then 1 else cs.simple i') * (cs.simple i * cs.simple i') ^ (m / 2)

full_name: CoxeterSystem.prod_alternatingWord_eq_prod_alternatingWord_sub
code: theorem prod_alternatingWord_eq_prod_alternatingWord_sub (i i' : B) (m : ℕ) (hm : m ≤ M i i' * 2) :
    π (alternatingWord i i' m) = π (alternatingWord i' i (M i i' * 2 - m)) 
goal: cs.wordProd (CoxeterSystem.alternatingWord i i' m) = cs.wordProd (CoxeterSystem.alternatingWord i' i (M.M i i' * 2 - m))

full_name: CoxeterSystem.wordProd_braidWord_eq
code: /-- The two words of length `M i i'` that alternate between `i` and `i'` have the same product.
This is known as the "braid relation" or "Artin-Tits relation". -/
theorem wordProd_braidWord_eq (i i' : B) :
    π (braidWord M i i') = π (braidWord M i' i) 
goal: cs.wordProd (CoxeterSystem.braidWord M i i') = cs.wordProd (CoxeterSystem.braidWord M i' i)