Skip to content

Commit 24e020a

Browse files
trivial1711eric-wieserjoelriou
committed
refactor(GroupTheory/Coxeter/Basic): Coxeter groups (#11836)
- Remove the definition `def Matrix.IsCoxeter : Prop`. Replace it with a type `CoxeterMatrix B`, which is the type of all Coxeter matrices indexed by `B`. - Simplify the definitions of Coxeter matrices `Aₙ` (`n : ℕ`), `Bₙ` (`n : ℕ`), `Dₙ` (`n : ℕ`), `I₂ₘ` (`m : ℕ`), `E₆`, `E₇`, `E₈`, `F₄`, `G₂`, `H₃`, and `H₄`. - All definitions involving a matrix (including the definition of a Coxeter group, Coxeter relation, and Coxeter system) now require the matrix to be a Coxeter matrix. - Update docstrings of `GroupTheory.Coxeter.Basic` and `GroupTheory.Coxeter.Matrix`. - The terms "Coxeter matrix", "Coxeter group", and "Coxeter system" are now defined in the header docstring. - It is now clearer that the rank of a Coxeter system can be infinite. - There is now a note in the implementation details of `GroupTheory.Coxeter.Matrix` about what happens when an entry of the Coxeter matrix is zero. - There is now a note in the implementation details of `GroupTheory.Coxeter.Basic` about how we try to state our results in terms of the type `B` that indexes the simple reflections, rather than the set $S$ of simple reflections. - Rename these definitions, structures, and theorems. Previously, there were six namespaces to keep track of: `Matrix`, `Matrix.IsCoxeter`, `CoxeterMatrix`, `CoxeterGroup`, `CoxeterGroup.Relations`, and `CoxeterSystem`. It was difficult to guess the fully qualified name of many theorems, and the names were not designed for use with field notation. Instead, we put everything into two namespaces: `CoxeterMatrix` and `CoxeterSystem`. - Rename `CoxeterGroup.Relations.ofMatrix` to `CoxeterMatrix.relation`. Also, change its type to `B → B → FreeGroup B` (from `B × B → FreeGroup B`). - Rename `CoxeterGroup.Relations.toSet` to `CoxeterMatrix.relationsSet`. - Rename `Matrix.CoxeterGroup` to `CoxeterMatrix.group`. - Rename `CoxeterGroup.of` to `CoxeterMatrix.simple`. - Remove `CoxeterSystem.funLike`. Rename `CoxeterSystem.funLike.coe` to `CoxeterSystem.simple`, because "simple reflection" (or "simple" for short) is the name used in the literature for this concept, and it is unintuitive to think of a Coxeter system as a function. - Rename `CoxeterSystem.funLike.coe_injective'` and `CoxeterSystem.ext'`, which are exactly the same theorem, to `CoxeterSystem.simple_determines_coxeterSystem`. (This theorem is forthcoming in #11406.) - Rename `CoxeterSystem.ofCoxeterGroup` to `CoxeterMatrix.toCoxeterSystem`. `CoxeterSystem.ofCoxeterGroup` is a confusing name because the input to the definition is an `CoxeterMatrix`, not a Coxeter group. - Rename `CoxeterSystem.ofCoxeterGroup_apply` to `CoxeterMatrix.toCoxeterSystem_simple` and remove `@[simp]`. The theorem doesn't have a Coxeter system as input and it does have a `CoxeterMatrix` as input, so it makes more sense for it to be in the `CoxeterMatrix` namespace. - Rename `CoxeterSystem.map_relations_eq_reindex_relations` to `CoxeterMatrix.reindex_relationsSet` and switch the two sides of the equality. The theorem doesn't mention Coxeter systems anywhere, so it shouldn't be in the `CoxeterSystem` namespace. Also, the new name better indicates what is on the left-hand side of the equality. - Rename `CoxeterSystem.equivCoxeterGroup` to `CoxeterMatrix.reindexGroupEquiv` and switch the two sides of the equivalence. The definition doesn't mention Coxeter systems anywhere, so it shouldn't be in the `CoxeterSystem` namespace. Also, the new name conveys that the definition is about the Coxeter group associated to a reindexed matrix, rather than merely conveying that it is about an isomorphism of Coxeter groups. - Rename `CoxeterSystem.equivCoxeterGroup_apply_of` to `CoxeterMatrix.reindexGroupEquiv_apply_simple`. - Rename `CoxeterSystem.equivCoxeterGroup_symm_apply_of` `CoxeterMatrix.reindexGroupEquiv_symm_apply_simple`. - Rename `CoxeterSystem.reindex_apply` to `CoxeterSystem.reindex_simple`. - Rename `CoxeterSystem.map_apply` to `CoxeterSystem.map_simple`. - Simplify several of the proofs. Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr>
1 parent b5ed949 commit 24e020a

File tree

2 files changed

+232
-258
lines changed

2 files changed

+232
-258
lines changed
Lines changed: 104 additions & 152 deletions
Original file line numberDiff line numberDiff line change
@@ -1,51 +1,45 @@
11
/-
22
Copyright (c) 2024 Newell Jensen. All rights reserved.
33
Released under Apache 2.0 license as described in the file LICENSE.
4-
Authors: Newell Jensen
4+
Authors: Newell Jensen, Mitchell Lee
55
-/
6-
import Mathlib.GroupTheory.Coxeter.Matrix
76
import Mathlib.GroupTheory.PresentedGroup
7+
import Mathlib.GroupTheory.Coxeter.Matrix
88

99
/-!
10-
# Coxeter Systems
11-
12-
This file defines Coxeter systems and Coxeter groups.
13-
14-
A Coxeter system is a pair `(W, S)` where `W` is a group generated by a set of
15-
reflections (involutions) `S = {s₁,s₂,...,sₙ}`, subject to relations determined
16-
by a Coxeter matrix `M = (mᵢⱼ)`. The Coxeter matrix is a symmetric matrix with
17-
entries `mᵢⱼ` representing the order of the product `sᵢsⱼ` for `i ≠ j` and `mᵢᵢ = 1`.
18-
19-
When `(W, S)` is a Coxeter system, one also says, by abuse of language, that `W` is a
20-
Coxeter group. A Coxeter group `W` is determined by the presentation
21-
`W = ⟨s₁,s₂,...,sₙ | ∀ i j, (sᵢsⱼ)^mᵢⱼ = 1⟩`, where `1` is the identity element of `W`.
22-
23-
The finite Coxeter groups are classified (TODO) as the four infinite families:
10+
# Coxeter groups and Coxeter systems
2411
25-
* `Aₙ, Bₙ, Dₙ, I₂ₘ`
12+
This file defines Coxeter groups and Coxeter systems.
2613
27-
And the exceptional systems:
14+
Let `B` be a (possibly infinite) type, and let $M = (M_{i,i'})_{i, i' \in B}$ be a matrix
15+
of natural numbers. Further assume that $M$ is a *Coxeter matrix* (`CoxeterMatrix`); that is, $M$ is
16+
symmetric and $M_{i,i'} = 1$ if and only if $i = i'$. The *Coxeter group* associated to $M$
17+
(`CoxeterMatrix.group`) has the presentation
18+
$$\langle \{s_i\}_{i \in B} \vert \{(s_i s_{i'})^{M_{i, i'}}\}_{i, i' \in B} \rangle.$$
19+
The elements $s_i$ are called the *simple reflections* (`CoxeterMatrix.simple`) of the Coxeter
20+
group. Note that every simple reflection is an involution.
2821
29-
* `E₆, E₇, E₈, F₄, G₂, H₃, H₄`
22+
A *Coxeter system* (`CoxeterSystem`) is a group $W$, together with an isomorphism between $W$ and
23+
the Coxeter group associated to some Coxeter matrix $M$. By abuse of language, we also say that $W$
24+
is a Coxeter group (`IsCoxeterGroup`), and we may speak of the simple reflections $s_i \in W$
25+
(`CoxeterSystem.simple`). We state all of our results about Coxeter groups in terms of Coxeter
26+
systems where possible.
3027
3128
## Implementation details
3229
33-
In this file a Coxeter system, designated as `CoxeterSystem M W`, is implemented as a
34-
structure which effectively records the isomorphism between a group `W` and the corresponding
35-
group presentation derived from a Coxeter matrix `M`. From another perspective, it serves as
36-
a set of generators for `W`, tailored to the underlying type of `M`, while ensuring compliance
37-
with the relations specified by the Coxeter matrix `M`.
38-
39-
A type class `IsCoxeterGroup` is introduced, for groups that are isomorphic to a group
40-
presentation corresponding to a Coxeter matrix which is registered in a Coxeter system.
30+
Much of the literature on Coxeter groups conflates the set $S = \{s_i : i \in B\} \subseteq W$ of
31+
simple reflections with the set $B$ that indexes the simple reflections. This is usually permissible
32+
because the simple reflections $s_i$ of any Coxeter group are all distinct (a nontrivial fact that
33+
we do not prove in this file). In contrast, we try not to refer to the set $S$ of simple
34+
reflections unless necessary; instead, we state our results in terms of $B$ wherever possible.
4135
4236
## Main definitions
4337
44-
* `Matrix.CoxeterGroup` : The group presentation corresponding to a Coxeter matrix.
45-
* `CoxeterSystem` : A structure recording the isomorphism between a group `W` and the
46-
group presentation corresponding to a Coxeter matrix, i.e. `Matrix.CoxeterGroup M`.
47-
* `equivCoxeterGroup` : Coxeter groups of isomorphic types are isomorphic.
48-
* `IsCoxeterGroup` : A group is a Coxeter group if it is registered in a Coxeter system.
38+
* `CoxeterMatrix.group`
39+
* `CoxeterSystem`
40+
* `IsCoxeterGroup`
41+
* `CoxeterSystem.simple` : If `cs` is a Coxeter system on the group `W`, then `cs.simple i` is the
42+
simple reflection of `W` at the index `i`.
4943
5044
## References
5145
@@ -56,162 +50,120 @@ presentation corresponding to a Coxeter matrix which is registered in a Coxeter
5650
5751
## TODO
5852
59-
* The canonical map from the type to the Coxeter group `W` is an injection.
60-
* A group `W` registered in a Coxeter system is a Coxeter group.
61-
* A Coxeter group is an instance of `IsCoxeterGroup`.
53+
* The simple reflections of a Coxeter system are distinct.
6254
6355
## Tags
6456
6557
coxeter system, coxeter group
58+
6659
-/
6760

61+
open Function
6862

69-
universe u
63+
/-! ### Coxeter groups -/
7064

71-
noncomputable section
65+
namespace CoxeterMatrix
7266

73-
variable {B : Type*} [DecidableEq B]
74-
variable (M : Matrix B B ℕ)
67+
variable {B B' : Type*} (M : CoxeterMatrix B) (e : B ≃ B')
7568

76-
namespace CoxeterGroup
69+
/-- The Coxeter relation associated to a Coxeter matrix $M$ and two indices $i, i' \in B$.
70+
That is, the relation $(s_i s_{i'})^{M_{i, i'}}$, considered as an element of the free group
71+
on $\{s_i\}_{i \in B}$.
72+
If $M_{i, i'} = 0$, then this is the identity, indicating that there is no relation between
73+
$s_i$ and $s_{i'}$. -/
74+
def relation (i i' : B) : FreeGroup B := (FreeGroup.of i * FreeGroup.of i') ^ M i i'
7775

78-
namespace Relations
76+
/-- The set of all Coxeter relations associated to the Coxeter matrix $M$. -/
77+
def relationsSet : Set (FreeGroup B) := Set.range <| uncurry M.relation
7978

80-
/-- The relations corresponding to a Coxeter matrix. -/
81-
def ofMatrix : B × B → FreeGroup B :=
82-
Function.uncurry fun b₁ b₂ => (FreeGroup.of b₁ * FreeGroup.of b₂) ^ M b₁ b₂
79+
/-- The Coxeter group associated to a Coxeter matrix $M$; that is, the group
80+
$$\langle \{s_i\}_{i \in B} \vert \{(s_i s_{i'})^{M_{i, i'}}\}_{i, i' \in B} \rangle.$$ -/
81+
protected def Group : Type _ := PresentedGroup M.relationsSet
8382

84-
/-- The set of relations corresponding to a Coxeter matrix. -/
85-
def toSet : Set (FreeGroup B) :=
86-
Set.range <| ofMatrix M
83+
instance : Group M.Group := QuotientGroup.Quotient.group _
8784

88-
end Relations
85+
/-- The simple reflection of the Coxeter group `M.group` at the index `i`. -/
86+
def simple (i : B) : M.Group := PresentedGroup.of i
8987

90-
end CoxeterGroup
88+
theorem reindex_relationsSet :
89+
(M.reindex e).relationsSet =
90+
FreeGroup.freeGroupCongr e '' M.relationsSet := let M' := M.reindex e; calc
91+
Set.range (uncurry M'.relation)
92+
_ = Set.range (uncurry M'.relation ∘ Prod.map e e) := by simp [Set.range_comp]
93+
_ = Set.range (FreeGroup.freeGroupCongr e ∘ uncurry M.relation) := by
94+
apply congrArg Set.range
95+
ext ⟨i, i'⟩
96+
simp [relation, reindex_apply, M']
97+
_ = _ := by simp [Set.range_comp]; rfl
9198

92-
/-- The group presentation corresponding to a Coxeter matrix. -/
93-
def Matrix.CoxeterGroup := PresentedGroup <| CoxeterGroup.Relations.toSet M
99+
/-- The isomorphism between the Coxeter group associated to the reindexed matrix `M.reindex e` and
100+
the Coxeter group associated to `M`. -/
101+
def reindexGroupEquiv : (M.reindex e).Group ≃* M.Group :=
102+
(QuotientGroup.congr (Subgroup.normalClosure M.relationsSet)
103+
(Subgroup.normalClosure (M.reindex e).relationsSet)
104+
(FreeGroup.freeGroupCongr e) (by
105+
rw [reindex_relationsSet,
106+
Subgroup.map_normalClosure _ _ (FreeGroup.freeGroupCongr e).surjective,
107+
← MulEquiv.coe_toMonoidHom]
108+
rfl)).symm
94109

95-
instance : Group (Matrix.CoxeterGroup M) :=
96-
QuotientGroup.Quotient.group _
110+
theorem reindexGroupEquiv_apply_simple (i : B') :
111+
(M.reindexGroupEquiv e) ((M.reindex e).simple i) = M.simple (e.symm i) := rfl
97112

98-
namespace CoxeterGroup
113+
theorem reindexGroupEquiv_symm_apply_simple (i : B) :
114+
(M.reindexGroupEquiv e).symm (M.simple i) = (M.reindex e).simple (e i) := rfl
99115

100-
/-- The canonical map from `B` to the Coxeter group with generators `b : B`. The term `b`
101-
is mapped to the equivalence class of the image of `b` in `CoxeterGroup M`. -/
102-
def of (b : B) : Matrix.CoxeterGroup M := PresentedGroup.of b
116+
end CoxeterMatrix
103117

104-
@[simp]
105-
theorem of_apply (b : B) : of M b = PresentedGroup.of (rels := Relations.toSet M) b :=
106-
rfl
107-
108-
end CoxeterGroup
109-
110-
/-- A Coxeter system `CoxeterSystem W` is a structure recording the isomorphism between
111-
a group `W` and the group presentation corresponding to a Coxeter matrix. Equivalently, this
112-
can be seen as a list of generators of `W` parameterized by the underlying type of `M`, which
113-
satisfy the relations of the Coxeter matrix `M`. -/
114-
structure CoxeterSystem (W : Type*) [Group W] where
115-
/-- `CoxeterSystem.ofMulEquiv` constructs a Coxeter system given an equivalence with the group
116-
presentation corresponding to a Coxeter matrix `M`. -/
117-
ofMulEquiv ::
118-
/-- `mulEquiv` is the isomorphism between the group `W` and the group presentation
119-
corresponding to a Coxeter matrix `M`. -/
120-
mulEquiv : W ≃* Matrix.CoxeterGroup M
118+
/-! ### Coxeter systems -/
121119

122-
/-- A group is a Coxeter group if it admits a Coxeter system for some Coxeter matrix `M`. -/
123-
class IsCoxeterGroup (W : Type u) [Group W] : Prop where
124-
nonempty_system : ∃ B : Type u, ∃ M : Matrix B B ℕ, M.IsCoxeter ∧ Nonempty (CoxeterSystem M W)
120+
section
125121

126-
namespace CoxeterSystem
122+
variable {B : Type*} (M : CoxeterMatrix B)
127123

128-
open Matrix
124+
/-- A Coxeter system `CoxeterSystem M W` is a structure recording the isomorphism between
125+
a group `W` and the Coxeter group associated to a Coxeter matrix `M`. -/
126+
@[ext]
127+
structure CoxeterSystem (W : Type*) [Group W] where
128+
/-- The isomorphism between `W` and the Coxeter group associated to `M`. -/
129+
mulEquiv : W ≃* M.Group
129130

130-
variable {B B' W H : Type*} [Group W] [Group H]
131-
variable {M : Matrix B B ℕ}
131+
/-- A group is a Coxeter group if it admits a Coxeter system for some Coxeter matrix `M`. -/
132+
class IsCoxeterGroup.{u} (W : Type u) [Group W] : Prop where
133+
nonempty_system : ∃ B : Type u, ∃ M : CoxeterMatrix B, Nonempty (CoxeterSystem M W)
132134

133-
/-- A Coxeter system for `W` with Coxeter matrix `M` indexed by `B`, is associated to
134-
a map `B → W` recording the images of the indices. -/
135-
instance funLike : FunLike (CoxeterSystem M W) B W where
136-
coe cs := fun b => cs.mulEquiv.symm (.of b)
137-
coe_injective' := by
138-
rintro ⟨cs⟩ ⟨cs'⟩ hcs'
139-
have H : (cs.symm : CoxeterGroup M →* W) = (cs'.symm : CoxeterGroup M →* W) := by
140-
unfold CoxeterGroup
141-
ext i; exact congr_fun hcs' i
142-
have : cs.symm = cs'.symm := by ext x; exact DFunLike.congr_fun H x
143-
rw [ofMulEquiv.injEq, ← MulEquiv.symm_symm cs, ← MulEquiv.symm_symm cs', this]
135+
/-- The canonical Coxeter system on the Coxeter group associated to `M`. -/
136+
def CoxeterMatrix.toCoxeterSystem : CoxeterSystem M M.Group := ⟨.refl _⟩
144137

145-
@[simp]
146-
theorem mulEquiv_apply_coe (cs : CoxeterSystem M W) (b : B) : cs.mulEquiv (cs b) = .of b :=
147-
cs.mulEquiv.eq_symm_apply.mp rfl
138+
end
148139

149-
/-- The map sending a Coxeter system to its associated map `B → W` is injective. -/
150-
theorem ext' {cs₁ cs₂ : CoxeterSystem M W} (H : ⇑cs₁ = ⇑cs₂) : cs₁ = cs₂ := DFunLike.coe_injective H
140+
namespace CoxeterSystem
151141

152-
/-- Extensionality rule for Coxeter systems. -/
153-
theorem ext {cs₁ cs₂ : CoxeterSystem M W} (H : ∀ b, cs₁ b = cs₂ b) : cs₁ = cs₂ :=
154-
ext' <| by ext; apply H
142+
open CoxeterMatrix
155143

156-
/-- The canonical Coxeter system of the Coxeter group over `X`. -/
157-
def ofCoxeterGroup (X : Type*) (D : Matrix X X ℕ) : CoxeterSystem D (CoxeterGroup D) where
158-
mulEquiv := .refl _
144+
variable {B B' : Type*} (e : B ≃ B')
145+
variable {W H : Type*} [Group W] [Group H]
146+
variable {M : CoxeterMatrix B} (cs : CoxeterSystem M W)
159147

160-
@[simp]
161-
theorem ofCoxeterGroup_apply {X : Type*} (D : Matrix X X ℕ) (x : X) :
162-
CoxeterSystem.ofCoxeterGroup X D x = CoxeterGroup.of D x :=
163-
rfl
164-
165-
theorem map_relations_eq_reindex_relations (e : B ≃ B') :
166-
(MulEquiv.toMonoidHom (FreeGroup.freeGroupCongr e)) '' CoxeterGroup.Relations.toSet M =
167-
CoxeterGroup.Relations.toSet (reindex e e M) := by
168-
simp only [MulEquiv.coe_toMonoidHom, FreeGroup.freeGroupCongr_apply, CoxeterGroup.Relations.toSet,
169-
CoxeterGroup.Relations.ofMatrix, reindex_apply, submatrix_apply]
170-
ext x
171-
simp only [Set.mem_image, Set.mem_range, Prod.exists, Function.uncurry_apply_pair]
172-
constructor
173-
· rintro ⟨x, ⟨a, b, rfl⟩, rfl⟩
174-
use e a, e b
175-
simp
176-
· rintro ⟨a, b, h⟩
177-
refine ⟨(FreeGroup.freeGroupCongr e).symm x, ⟨e.symm a, e.symm b, ?_⟩, ?_⟩ <;> aesop
178-
179-
/-- Coxeter groups of isomorphic types are isomorphic. -/
180-
def equivCoxeterGroup (e : B ≃ B') : CoxeterGroup M ≃* CoxeterGroup (reindex e e M) :=
181-
QuotientGroup.congr (Subgroup.normalClosure (CoxeterGroup.Relations.toSet M))
182-
(Subgroup.normalClosure (CoxeterGroup.Relations.toSet (reindex e e M)))
183-
(FreeGroup.freeGroupCongr e) (by
184-
have := Subgroup.map_normalClosure (CoxeterGroup.Relations.toSet M)
185-
(FreeGroup.freeGroupCongr e).toMonoidHom (FreeGroup.freeGroupCongr e).surjective
186-
rwa [map_relations_eq_reindex_relations] at this)
148+
/-- Reindex a Coxeter system through a bijection of the indexing sets. -/
149+
@[simps]
150+
protected def reindex (e : B ≃ B') : CoxeterSystem (M.reindex e) W :=
151+
⟨cs.mulEquiv.trans (M.reindexGroupEquiv e).symm⟩
187152

188-
theorem equivCoxeterGroup_apply_of (b : B) (M : Matrix B B ℕ) (e : B ≃ B') :
189-
(equivCoxeterGroup e) (CoxeterGroup.of M b) = CoxeterGroup.of (reindex e e M) (e b) :=
190-
rfl
153+
/-- Push a Coxeter system through a group isomorphism. -/
154+
@[simps] protected def map (e : W ≃* H) : CoxeterSystem M H := ⟨e.symm.trans cs.mulEquiv⟩
191155

192-
theorem equivCoxeterGroup_symm_apply_of (b' : B') (M : Matrix B B ℕ) (e : B ≃ B') :
193-
(equivCoxeterGroup e).symm (CoxeterGroup.of (reindex e e M) b') =
194-
CoxeterGroup.of M (e.symm b') :=
195-
rfl
156+
/-! ### Simple reflections -/
196157

197-
/-- Reindex a Coxeter system through a bijection of the indexing sets. -/
198-
@[simps]
199-
protected def reindex (cs : CoxeterSystem M W) (e : B ≃ B') :
200-
CoxeterSystem (reindex e e M) W :=
201-
ofMulEquiv (cs.mulEquiv.trans (equivCoxeterGroup e))
158+
/-- The simple reflection of `W` at the index `i`. -/
159+
def simple (i : B) : W := cs.mulEquiv.symm (PresentedGroup.of i)
202160

203161
@[simp]
204-
theorem reindex_apply (cs : CoxeterSystem M W) (e : B ≃ B') (b' : B') :
205-
cs.reindex e b' = cs (e.symm b') :=
206-
rfl
162+
theorem _root_.CoxeterMatrix.toCoxeterSystem_simple (M : CoxeterMatrix B) :
163+
M.toCoxeterSystem.simple = M.simple := rfl
207164

208-
/-- Pushing a Coxeter system through a group isomorphism. -/
209-
@[simps]
210-
protected def map (cs : CoxeterSystem M W) (e : W ≃* H) : CoxeterSystem M H :=
211-
ofMulEquiv (e.symm.trans cs.mulEquiv)
165+
@[simp] theorem reindex_simple (i' : B') : (cs.reindex e).simple i' = cs.simple (e.symm i') := rfl
212166

213-
@[simp]
214-
theorem map_apply (cs : CoxeterSystem M W) (e : W ≃* H) (b : B) : cs.map e b = e (cs b) :=
215-
rfl
167+
@[simp] theorem map_simple (e : W ≃* H) (i : B) : (cs.map e).simple i = e (cs.simple i) := rfl
216168

217169
end CoxeterSystem

0 commit comments

Comments
 (0)