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 j*rangle
]

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.

`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).

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(`

can be applied to `b`)`b`. See the Chapter on Coxeter cosets.

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

`PermBraid( `

`b` )

Returns the image of the braid element `b` in the Coxeter group
`CoxeterGroup(`

of which `b`)`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).

`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).

`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(`

are all good elements of minimal length in their
class.
`W`)

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