# 79 Artin-Tits braid groups

Let W be a Coxeter group, with presentation [ langle s_1, ldots , s_n mid s_i^2=1, underbraces_is_js_icdots_m(i,j)text factors = underbraces_js_is_jcdots_m(i,j)text factors quad textfor all i, j with i neq j rangle ] for some Coxeter matrix M= {m(i,j)}_{i,j} such that the Coxeter group is finite. The braid group B=B(M) associated to W is the group defined by the presentation [ langle bs_1, ldots , bs_n mid underbracebs_ibs_jbs_icdots_m(i,j)text factors = underbracebs_jbs_ibs_jcdots_m(i,j)text factors quad textfor all i, j with i neq jrangle ]

Usually, we will use the same symbols for generators and elements of W and of B, except that we will use bold letters for elements of B. This is justified by the fact that there is a canonical section to the natural quotient map B rightarrow W given as follows. Let w in W and choose a reduced expression w=s_1 cdots s_m. Then the corresponding product bw=bs_1 cdots bs_m in B is independent of the chosen minimal expression. Let B^+ be the submonoid of B consisting of all words in the generators bs_i of B (words with no inverses); in this way, we can identify W with the subset B^+_{text{red}} of B^+ which consists of the elements of B^{+} of the same length as their image in~W.

If W is a real reflection group in the vector space V with root system R, then B has also a topological definition as the fundamental group Pi^1 of the space ((V-bigcup_{r in R} H_r) otimes CC)/W, where H_r is the hyperplane orthogonal to the root r; however, we will not use this here.

We will represent in GAP words of the braid group associated to the Coxeter group W using a normal form based on theorems of Deligne Del72 (which extend previous work of Brieskorn, Saito BS72 and Garside Gar69):

renewcommandlabelenumi(romanenumi) item Let bw_0 be the element in B^+ which lifts the longest element of W, as explained above. Then, given any element bb in B, there is some power bw_0^i such that bw_0^ibb in B^+. item Let bb in B^+. Then there is a unique longest element alpha(bb) of B^+_{text{red}} which divides bb on the left (which means that bb=alpha(bb)by for some by in B^+).

We use (i) and (ii) to represent an element bb in B: we first compute the smallest power of bw_0 such that bw_0^ibb in B^+, and we represent bb by the couple (i,bw_0^ibb). We are thus reduced to the case where bb in B^+. We then represent bb by the sequence of elements of the Coxeter group alpha(bb), alpha(alpha(bb)^{-1}bb), ldots. Given a Coxeter group W, the function `Braid(W)` constructs an element of the associated braid group from a list of generators. Here is an example:

```    gap> W := CoxeterGroup( "A", 4 );;
gap> w := Braid( W )( 1, 2, 3, 4 );
1234
gap> w ^ 3;
121321432.343
gap> w ^ 4;
w0^1.232432
gap> w ^ -1;
w0^-1.232432 ```

How the element is printed exactly is controlled by the variable `PrintBraid`. This variable is a component of the global file `CHEVIE`, and the user can change its value whenever he or she wants during a GAP session. When you load the CHEVIE package, `CHEVIE.PrintBraid` is initialized to the string `"Deligne"`, as in the above examples. If it is set to `"GAP"`, then the element is printed in a form which after assigning `B:=Braid(W);` can be input back into GAP:

```    gap> CHEVIE.PrintBraid;
"Deligne"
gap> CHEVIE.PrintBraid := "GAP";
"GAP"
gap> w;
B([ 1, 2, 3, 4 ])
gap> w ^ 3;
B([ 1, 2, 1, 3, 2, 1, 4, 3, 2, 3, 4, 3 ])
gap> w ^ -1;
B([ 2, 3, 2, 4, 3, 2 ],-1) ```

The third possible value `"Charney"` for `CHEVIE.PrintBraid` is based on an idea of Ruth Charney Cha92 to find the smallest element by in B^+ such that by.bb in B^+, and print bb by printing (by)^{-1} followed by the Deligne normal form of by.bb :

```    gap> CHEVIE.PrintBraid := "Charney";
"Charney"
gap> w ^ -1;
(1234)^-1. ```

## 79.1 Construction of braid elements

`Braid( W )( s1, .., sn )`

`Braid( W )( list [, pw0 ])`

`Braid( W )( p [, pw0 ])`

Let W be a Coxeter group and let w be an element of W, represented as a permutation p of the roots, or as a sequence s_1,..,s_n of integers representing a (non necessarily reduced) word in the generators of W. The calls above return the element of the braid monoid of W defined by w. If pw0 (a positive or negative integer) is given, the resulting element is multiplied in the braid group by bw_0^{pw0}. The result of `Braid(W)` is a braid-making function, which can be assigned to make conveniently braid elements as in the example below.

A braid element bb corresponding to the Coxeter group W is represented as a record with fields `pw0`, `elm` and `operations`. `elm` represents an element bx in B^+, and `elm` and `pw0` are such that bb=bw_0^{text{pw0}}bx and bw_0^{-1}bxnotin B^+. `elm` is a sequence of elements of W (permutations of the roots), which are the image in W of alpha(bb), alpha(alpha(bb)^{-1}bb),ldots. Operations for braid elements.

```    gap> CHEVIE.PrintBraid := "Deligne";;
gap> W := CoxeterGroup( "A", 3 );;
gap> B := Braid( W );
function ( arg ) ... end
gap> B( W.generators[1] );
1
gap> B( 2, 1, 2, 1, 1 );
121.1.1
gap> B( [ 2, 1, 2, 1, 1 ], -1 );
w0^-1.121.1.1 ```

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

## 79.2 Operations for braid elements

A braid element bb corresponding to the Coxeter group W is represented as a record with fields `pw0`, `elm` and `operations` which contains the operations described below. All examples below are with `CHEVIE.PrintBraid="Deligne"`.

`b1 * b2`

The multiplication of two braid elements is defined, if they are braid elements of the same group, returning a braid element.

```    gap> W := CoxeterGroup( "A", 2 );;
gap> a := Braid( W )( [1] );
1
gap> b := Braid( W )( [2] );
2
gap> a * b;
12 ```

`b1 ^ i`

A braid element can be raised to an integral, positive or negative, power, returning a braid element.

```    gap> ( a * b ) ^ 4;
w0^2.12
gap> ( a * b ) ^ -1;
w0^-1.2 ```

`b1 ^ b2`

This returns b_1^{-1}b_2b_1.

```    gap> a ^ b;
w0^-1.21.12 ```

`b1 / b2`

This returns b_1b_2^{-1}.

```    gap> a / b;
w0^-1.2.21 ```

`CoxeterGroup( b )`

This function returns the Coxeter group for which b is a braid element.

```    gap> CoxeterGroup( a );
CoxeterGroup("A", 2) ```

`String( b )`

`Print( b )`

`String` returns a display form of the element b, and `Print` prints the result of `String`. The way elements are printed depends on the global variable `CHEVIE.PrintBraid`. If set to `"GAP"`, the elements are printed in a form which can be read in back by the function `Braid(W)`. If set to `"Deligne"` (resp. `"Charney"`) the Deligne (resp. Charney) normal form (as explained in the introduction) is printed:

```    gap> CHEVIE.PrintBraid := "GAP";;
gap> ( a * b ) ^ -1;
B([ 2 ],-1)
gap> CHEVIE.PrintBraid := "Charney";;
gap> ( a * b ) ^ -1;
(12)^-1.
gap> CHEVIE.PrintBraid := "Deligne";;
gap> ( a * b ) ^ -1;
w0^-1.2 ```

`Frobenius( WF )( b )`

The Frobenius of a Coxeter coset associated to `CoxeterGroup(b)` can be applied to b. See the Chapter on Coxeter cosets.

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

## 79.3 PermBraid

`PermBraid( b )`

Returns the image of the braid element b in the Coxeter group `CoxeterGroup(b)` of which b is a braid element.

```    gap>  W := CoxeterGroup( "A", 3 );;
gap>  b := Braid( W )( [ 2, 1, 2, 1, 1 ] );
121.1.1
gap> p := PermBraid( b );
( 1, 8)( 2, 7)( 3, 6)( 4,10)( 9,12)
gap> CoxeterWord( W, p );
[ 1, 2, 1 ] ```

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

## 79.4 WordBraid

`WordBraid( b )`

b is a braid element which must be in the braid monoid. `WordBraid` returns as a list of indices the list of generators of the braid monoid B(W) of which b is an element (the group W can be obtained by `CoxeterGroup(b)`).

```    gap>  W := CoxeterGroup( "A", 3 );;
gap>  b := Braid( W )( [ 2, 1, 2, 1, 1 ] );
121.1.1
gap> WordBraid( b );
[ 1, 2, 1, 1, 1 ] ```

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

## 79.5 GoodCoxeterWord

`GoodCoxeterWord( W, w )`

Let W be a Coxeter group with associated braid monoid B^+. `GoodCoxeterWord` checks if the element w of W (given as sequence of generators of W) represents a ``good element'' in the sense of Geck-Michel GM97 of the braid monoid, i.e., if bw^d (where d is the order of the element w in W, and bw is the element of B^+_{text{red}} with image w) is a product of (the braid elements corresponding to) longest elements in a decreasing chain of parabolic subgroups of W. If this is true, then a list of couples, the corresponding subsets of the generators with their multiplicities in the chain, is returned. Otherwise, `false` is returned.

Good elements have nice properties with respect to their eigenvalues in irreducible represen-tations of the Hecke-Iwahori algebra associated to W. The representatives in the component `classtext` of `ChevieClassInfo(W)` are all good elements of minimal length in their class.

```    gap> W := CoxeterGroup( "F", 4 );;
gap> w:=[ 2, 3, 2, 3, 4, 3, 2, 1, 3, 4 ];;
gap> GoodCoxeterWord( W, w );
[ [ [ 1 .. 4 ], 2 ], [ [ 3, 4 ], 4 ] ]
gap> OrderPerm( PermCoxeterWord( W, w ) );
6
gap> Braid( W )( w ) ^ 6;
w0^2.343.343.343.343
gap>  GoodCoxeterWord( W, [ 3, 2, 3, 4, 3, 2, 1, 3, 4, 2 ] );
false ```

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

GAP 3.4.4
April 1997