# 78 Reflection subgroups

Let W be a finite Coxeter group, corresponding to a root system R in an Euclidean space V. Let S be the set of generators corresponding to some system of fundamental roots in R. Then {wsw^{-1} mid w in W, s in S} is the set of all reflections in W. A reflection subgroup H of W is a subgroup generated by the reflections it contains. If H is generated by reflections with respect to a subset of the fundamental roots it is called a standard parabolic subgroup of W. A parabolic subgroup is a subgroup H of W which is conjugate to some standard parabolic subgroup. A parabolic subgroup H is characterized among all reflection subgroups of W by the fact that the set of all roots in R for which the corresponding reflection lies in H is closed under (real) linear combinations.

It is a theorem discovered by Deodhar Deo89 and Dyer Dye90 independently at the same time that a reflection subgroup H has a canonical set of fundamental roots even if it is not parabolic: Let Q be the set of all roots for which the corresponding reflection lies in H; then a fundamental system of roots for H is given by the positive roots t in Q such that the set of roots whose sign is changed by the reflection with root t meets Q in the single element t. This is used by the routine `ReflectionSubgroup` to determine the root system Q of a reflection subgroup H. This function takes the original record for W and a list of indices for the roots as input.

```    gap> W := CoxeterGroup( "G", 2 );
CoxeterGroup("G", 2)
gap> W.roots[4];
[ 1, 2 ]
gap> H := ReflectionSubgroup( W, [ 2, 4 ] );
ReflectionSubgroup(CoxeterGroup("G", 2), [ 2, 3 ])
gap> PrintDynkinDiagram( H );
~A2    2 - 3                           # not a parabolic subgroup ```

We also see that the result of the above algorithm is that `W.roots[2]` and `W.roots[3]` form a system of simple roots in H.

The line containing the Dynkin diagram of H introduces a convention: we use the notation `"~A"` to denote a root subsystem of type `"A"` generated by short roots.

The record for the subgroup contains additional components the most important of which is `rootInclusion` which gives the positions of the roots in Q in the original root system R:

```    gap> H.rootInclusion;
[ 2, 3, 4, 8, 9, 10 ] ```
The inverse map is stored in `H.rootRestriction`. If H is a standard parabolic subgroup of W then the length function on H (with respect to its set of generators) is the restriction of the length function on W. This need not no longer be true for arbitrary reflection subgroups of W:

```    gap> CoxeterLength( W, H.generators[2] );
3
gap> CoxeterLength( H, H.generators[2] );
1 ```

In GAP, the Coxeter group W is represented as a permutation group on R. Consequently, a reflection subgroup H subseteq W is a permutation subgroup, i.e., its elements are represented as permutations of the roots of the it parent group. This has to be kept in mind when working with reduced expressions and functions like `CoxeterWord`, and `PermCoxeterWord`.

Reduced words in simple reflections of H:

```    gap> el := CoxeterWords( H );
[ [  ], [ 2 ], [ 3 ], [ 2, 3 ], [ 3, 2 ], [ 2, 3, 2 ] ]```

Reduced words in the generators of H:

```    gap> el1 := List( el, x -> H.rootRestriction{ x } );
[ [  ], [ 1 ], [ 2 ], [ 1, 2 ], [ 2, 1 ], [ 1, 2, 1 ] ]```

Permutations on the roots of W:

```    gap> el2 := List( el, x -> PermCoxeterWord( H, x ) );
[ (), ( 1, 5)( 2, 8)( 3, 4)( 7,11)( 9,10),
( 1,12)( 2, 4)( 3, 9)( 6, 7)( 8,10),
( 1, 5,12)( 2,10, 3)( 4, 9, 8)( 6, 7,11),
( 1,12, 5)( 2, 3,10)( 4, 8, 9)( 6,11, 7),
( 2, 9)( 3, 8)( 4,10)( 5,12)( 6,11) ]```

Reduced words in the generators of W:

```    gap> List( el2, x -> CoxeterWord( W, x ) );
[ [  ], [ 2 ], [ 1, 2, 1 ], [ 2, 1, 2, 1 ], [ 1, 2, 1, 2 ],
[ 2, 1, 2, 1, 2 ] ]```

Another basic result about reflection subgroups is that each coset of H in W contains a unique element of minimal length. Since a coset is a subset of W, the length of elements is taken with respect to the roots of W.) See ReducedRightCosetRepresentatives.

In many applications it is useful to know the decomposition of the irreducible characters of W when we restrict them from W to a reflection subgroup H (defined as in Section~refReflection subgroups). In order to apply the usual GAP functions for inducing and restricting characters and computing scalar products, we need to know the fusion map for the conjugacy classes of H into those of W. This is done, as usual, with the GAP function `FusionConjugacyClasses`, which calls a special implementation for Coxeter groups. The decomposition of induced characters into irreducibles then is a simple matter of combining some functions which already exist in GAP. There is an additional function, `InductionTable`, which performs this job.

```    gap> W := CoxeterGroup( "G", 2 );;
gap> W.roots[4];
[ 1, 2 ]
gap> H := ReflectionSubgroup( W, [ 2, 4 ] );;
gap> Display( InductionTable( H, W ) );
Induction from ~A2 into G2
```
tt |
``` 111 21 3
______________________
phi_{1,0}   ```
tt |
```   .  . 1
phi_{1,6}   ```
tt |
```   1  . .
phi_{1,3}'  ```
tt |
```   .  . 1
phi_{1,3}'' ```
tt |
```   1  . .
phi_{2,1}   ```
tt |
```   .  1 .
phi_{2,2}   ```
tt |` . 1 . `

We have similar functions for the j-induction and the J-induction of characters. These operations are obtained by truncating the induced characters by using the a-invariants and b-invariants associated with jInductionTable for Macdonald-Lusztig-Spaltenstein induction and JInductionTable).

## 78.1 ReflectionSubgroup

`ReflectionSubgroup( W, r )`

Returns the reflection subgroup of the real reflection group W generated by the reflections with roots specified by r. r is a list of indices specifying a subset of the roots of W.

A reflection subgroup H of W is a permutation subgroup, and otherwise has the same fields as a Coxeter group, with some new ones added which express the relationship with the parent W:

`rootInclusion`:

the indices of the roots in the roots of W

`parentN`:

the number of positive roots of W

`rootRestriction`:

a list of length `2*H.parentN` with entries in positions `H.rootInclusion` bound to `[1..2*H.N]`.

A Coxeter group which is not a subgroup actually also contains these fields, set to the trivial values: `rootInclusion = [ 1 .. 2*W.N ]`, `parentN = W.N` and `rootRestriction = [ 1 .. 2*W.N ]`.

With these fields, you can, e.g., test if the i-th fundamental root of H root is left positive by the element w of H (given as a permutation of the roots of the parent) with

` H.rootInclusion[ i ] ^ w <= H.parentN`

Programs dealing with Coxeter groups should be written this way to work for Coxeter subgroups (instead of just writing `i^w <= H.N`).

`ReflectionSubgroup` returns a subgroup of the parent group of the argument (like the GAP function `Subgroup`).

```    gap> W := CoxeterGroup( "F", 4 );;
gap> H := ReflectionSubgroup( W, [ 1, 2, 11, 20 ] );
ReflectionSubgroup(CoxeterGroup("F", 4), [ 1, 2, 9, 16 ])
gap> CartanName( H );
"D4"                           # not a parabolic subgroup
gap> H.rootRestriction;
[ 1, 2,,, 5,,,, 3,, 6,,, 8,, 4,, 7,, 9,, 10, 11, 12, 13, 14,,, 17,,,,
15,, 18,,, 20,, 16,, 19,, 21,, 22, 23, 24 ]
gap> ReflectionSubgroup( H, [ 1, 2, 6 ] );
ReflectionSubgroup(CoxeterGroup("F", 4), [ 1, 2, 3 ]) ```

This function requires the package "chevie" (see RequirePackage).

## 78.2 Functions for reflection subgroups

All functions for Coxeter groups are actually defined for reflection subgroups. The generators for the subgroups are labeled according to the corresponding number of the root they represent in the parent group. This affects the labeling given by all functions dealing with words and generators, e.g., `PrintDynkinDiagram` or `PermCoxeterWord`.

```    gap> W := CoxeterGroup( "F", 4 );
CoxeterGroup("F", 4)
gap> H := ReflectionSubgroup( W, [ 10, 11, 12 ] );
ReflectionSubgroup(CoxeterGroup("F", 4), [ 10, 11, 12 ])
gap> PrintDynkinDiagram( H );
C2    11 > 10
~A1    12
gap> LongestCoxeterWord( H );
[ 10, 11, 10, 11, 12 ] ```

Also, as one may notice in the example above, there is one particularity of the functions `CartanType`, `CartanName` and `PrintDynkinDiagram` for Coxeter subgroups: an irreducible subsystem which consists of short roots in a system which has longer roots (i.e., type `"B"`, `"C"`, `"G"` or `"F"`) is labeled as type `"~A"`.

These functions require the package "chevie" (see RequirePackage).

## 78.3 ReducedInCoxeterCoset

`ReducedInCoxeterCoset( W , w )`

w is an automorphism of the Coxeter group W or of a parent group of W, given as a permutation of the roots. `ReducedInCoxeterCoset` returns the unique element in the right coset W.w which sends all roots of W to positive roots.

```    gap> W := CoxeterGroup("F", 4 );;
gap> H := ReflectionSubgroup( W, [ 1, 2, 9, 16 ] );;
gap> PrintDynkinDiagram( H );
D4   9
\
1 - 16
/
2
gap> w := PermCoxeterWord( W, [ 3, 2, 3, 4, 3, 2 ] );;
gap> f := ReducedInCoxeterCoset( H, w );;
gap> CoxeterWord( W, f );
[ 4, 3 ]
gap> H.rootInclusion{[ 1 ..4 ]};
[ 1, 2, 9, 16 ]```

The triality automorphism of D_4:

```    gap> OnTuples( H.rootInclusion{[ 1 .. 4 ]}, f );
[ 1, 9, 16, 2 ]```
This function requires the package "chevie" (see RequirePackage).

## 78.4 ReducedRightCosetRepresentatives

`ReducedRightCosetRepresentatives( W, H )`

returns a list of reduced elements in the Coxeter group W which are distinguished representatives for the right cosets of the reflection subgroup H in W. The distinguished representative in the coset H.w is the unique element in the coset which sends all roots of H to positive roots (the element returned by `ReducedInCoxeterCoset`). It is also the element of minimal length in the coset. The representatives are returned in order of increasing length.

```    gap> W := CoxeterGroup( "B", 3 );;
gap> H := ReflectionSubgroup(W, [ 2, 3 ]);;
gap> List( ReducedRightCosetRepresentatives( W, H ),
>                                x-> CoxeterWord( W, x ) );
[ [  ], [ 1 ], [ 1, 2 ], [ 1, 2, 1 ], [ 1, 2, 3 ], [ 1, 2, 1, 3 ],
[ 1, 2, 1, 3, 2 ], [ 1, 2, 1, 3, 2, 1 ] ] ```

This function requires the package "chevie" (see RequirePackage).

## 78.5 PermCosetsSubgroup

`PermCosetsSubgroup( W, H )`

returns the list of permutations induced by the standard generators of the Coxeter group W on the cosets of the Coxeter subgroup H. The cosets are in the order determined by the result of the function `ReducedRightCosetRepresentatives( W, H )`.

```    gap> W := CoxeterGroup( "F", 4 );;
gap> PermCosetsSubgroup( W, ReflectionSubgroup( W, [ 1, 2, 3 ] ) );
[ ( 4, 5)( 6, 7)( 8,10)(16,18)(17,20)(19,21),
( 3, 4)( 7, 9)(10,12)(14,16)(15,17)(21,22),
( 2, 3)( 4, 6)( 5, 7)( 9,11)(12,14)(13,15)(17,19)(20,21)(22,23),
( 1, 2)( 6, 8)( 7,10)( 9,12)(11,13)(14,15)(16,17)(18,20)(23,24) ] ```

This function requires the package "chevie" (see RequirePackage).

## 78.6 jInductionTable for Macdonald-Lusztig-Spaltenstein induction

`jInductionTable( H, W )`

computes the decomposition into irreducible characters of W of the j-induced of the irreducible characters of H. The j-induced of chi is the sum of the irreducible components of the induced of chi which have same b-function (see LowestPowerFakeDegrees) as chi. In the table the rows correspond to the characters of the parent group, the columns to those of the subgroup. What is returned is actually a record with several fields: `scalar` contains the induction table proper, and there is a `Display` method. The other fields contain labeling information taken from the character tables of H and W when it exists.

```    gap> W := CoxeterGroup( "D", 4);;
gap> H := ReflectionSubgroup( W, [ 1, 3 ] );;
gap> Display( jInductionTable( H, W ) );
j-Induction from A2 into D4
```
tt |
``` 111 21 3
________________
11.+  ```
tt |
```   .  . .
11.-  ```
tt |
```   .  . .
1.111 ```
tt |
```   .  . .
.1111 ```
tt |
```   .  . .
11.2  ```
tt |
```   .  . .
1.21  ```
tt |
```   1  . .
.211  ```
tt |
```   .  . .
2.+   ```
tt |
```   .  . .
2.-   ```
tt |
```   .  . .
.22   ```
tt |
```   .  . .
1.3   ```
tt |
```   .  1 .
.31   ```
tt |
```   .  . .
.4    ```
tt |` . . 1 `

This function requires the package "chevie" (see RequirePackage).

## 78.7 JInductionTable

`JInductionTable( H, W )`

`JInductionTable` computes the decomposition into irreducible characters of W of the J-induced of the irreducible characters of H. The J-induced of chi is the sum of the irreducible components of the induced of chi which have same a-function (see LowestPowerGenericDegrees) as chi. In the table the rows correspond to the characters of the parent group, the columns to those of the subgroup. What is returned is actually a record with several fields: `scalar` contains the induction table proper, and there is a `Display` method. The other fields contain labeling information taken from the character tables of H and W when it exists.

```    gap> W := CoxeterGroup( "D", 4 );;
gap> H := ReflectionSubgroup( W, [ 1, 3 ] );;
gap> Display( JInductionTable( H, W ) );
J-Induction from A2 into D4
```
tt |
``` 111 21 3
________________
11.+  ```
tt |
```   .  . .
11.-  ```
tt |
```   .  . .
1.111 ```
tt |
```   .  . .
.1111 ```
tt |
```   .  . .
11.2  ```
tt |
```   1  . .
1.21  ```
tt |
```   1  . .
.211  ```
tt |
```   .  . .
2.+   ```
tt |
```   .  . .
2.-   ```
tt |
```   .  . .
.22   ```
tt |
```   .  . .
1.3   ```
tt |
```   .  1 .
.31   ```
tt |
```   .  . .
.4    ```
tt |` . . 1 `

This function requires the package "chevie" (see RequirePackage). Previous Up Next
Index

GAP 3.4.4
April 1997