# 81 Iwahori-Hecke algebras

In this chapter we describe functions for dealing with Iwahori-Hecke algebras associated to finite Coxeter groups.

Let W be a finite Coxeter group, with generators S={s_1,ldots,s_n}. As before, let m(i,j) denote the order of the product s_is_j. Let R be a commutative ring with~1 and q_1,ldots,q_n be elements in R such that q_i=q_j whenever m(i,j) is odd. Thus, we have q_i=q_j whenever s_i and s_j are conjugate in W. The corresponding Iwahori-Hecke algebra with parameters {q_i} is a deformation of the group algebra of W over R where the multiplication of basis elements involves the parameters q_i and where the deformation is trivial if all q_i are equal to 1.

More precisely, the Iwahori-Hecke algebra H=H(W,R, {q_i}) is the associative R-algebra with 1 = T_1 generated by elements T_{s_1},ldots,T_{s_n} subject to the following relations. [ beginarrayccll (T_s_i-q_i)(T_s_i+1) & = & 0 & mbox for all; i
T_s_iT_s_jT_s_i cdots & = & T_s_jT_s_iT_s_j cdots & mbox for i neq j and with m(i,j) factors on each side. endarray ] Since the generators T_{s_i} satisfy the braid relations, the algebra H is in fact a quotient of the group algebra of the braid group associated with W. It follows that, if w=s_{i_1} cdots s_{i_m}= s_{j_1} cdots s_{j_m} are two reduced expressions of w in W as products of fundamental reflections then the corresponding products of the generators T_{s_i} respectively T_{s_j} will give the same element of H, which we may therefore denote by T_w. Then the elements {T_w mid w in W} actually form a free R-basis of H. The multiplication of two arbitrary basis elements T_v,T_w (for v,w in W) is then performed as follows. Choose a reduced expression for v, say v=s_{i_1} cdots s_{i_k}. Then T_v is the product of the corresponding generators T_{s_i} hence we are reduced to the case where v=s_i for some i. In this case, we have [ T_s_iT_w = left{ beginarraycl T_s_iw & mbox if l(s_iw)=l(w)+1
q_iT_s_iw+(q_i-1)T_w & mbox if l(s_iw)=l(w)-1. endarrayright. ] There is a universal choice for R and {q_i}: Let u_1,ldots,u_n be indeterminates over QQ such that u_i=u_j whenever m(i,j) is odd, and let A_0={ZZ}[u_1,ldots,u_n] be the corresponding polynomial ring. Then H_0:=H(W,A_0,{u_i}) is called the generic Iwahori-Hecke algebra associated with W. If R and {q_i} are given as above then H(W,R,{q_i}) can be obtained by specialization from H_0: There is a unique ring homomorphism f:A_0 rightarrow R such that f(u_i)=q_i for all i. Then we can view R as an A_0-module via f and we can identify H(W,R,{q_i})=R otimes _{A_0} H_0.

If all u_i are equal we call the corresponding algebra the one-parameter Iwahori-Hecke algebra associated with W. Certain invariants associated with the irreducible characters of this algebra play a special role in the representation theory of the underlying finite Coxeter groups, namely the a- and A-invariants which were already used in chapter Character tables for Coxeter groups (see LowestPowerGenericDegrees, JInductionTable).

For basic properties of Iwahori-Hecke algebras and their relevance to the representation theory of finite groups of Lie type, we refer to CR87, Sections~67 and 68.

In the following example, we compute the multiplication table for the 0-Iwahori--Hecke algebra associated with the Coxeter group of type A_2.

```    gap> W := CoxeterGroup( "A", 2 );
CoxeterGroup("A", 2)```

Algebra with all parameters equal to 0:

```    gap> H := Hecke( W, 0 );
Hecke(CoxeterGroup("A", 2),[ 0, 0 ],[  ])```

Create the T-basis:

```    gap> T := Basis( H, "T" );
function ( arg ) ... end
gap> el := CoxeterWords( W );
[ [  ], [ 2 ], [ 1 ], [ 2, 1 ], [ 1, 2 ], [ 1, 2, 1 ] ]```

Multiply any two T-basis elements:

```    gap> mat := []; for i in [1..6] do mat[i]:=[]; for j in [1..6] do
> Add( mat[i], T( el[i]) * T( el[j] ) ); od; od;
gap> PrintArray(mat);
[ [     T(),       T(2),      T(1),    T(2,1),    T(1,2),  T(1,2,1) ],
[    T(2),      -T(2),    T(2,1),   -T(2,1),  T(1,2,1), -T(1,2,1) ],
[    T(1),     T(1,2),     -T(1),  T(1,2,1),   -T(1,2), -T(1,2,1) ],
[  T(2,1),   T(1,2,1),   -T(2,1), -T(1,2,1), -T(1,2,1),  T(1,2,1) ],
[  T(1,2),    -T(1,2),  T(1,2,1), -T(1,2,1), -T(1,2,1),  T(1,2,1) ],
[ T(1,2,1), -T(1,2,1), -T(1,2,1),  T(1,2,1),  T(1,2,1), -T(1,2,1) ] ]```
Thus, we can not only work with generic algebras where the parameters are indeterminates. In the following chapter we will see that this also works on the level of characters and representations.

## 81.1 Hecke

`Hecke( W , [parameter(s), [sqrtparameter(s)]] )`

`Hecke( rec )`

Constructs the Iwahori-Hecke algebra H of the given Coxeter group. parameters can be either a vector of length `W.semisimpleRank`, giving the parameter for each fundamental reflection, or a single value which is taken as the common parameter. Similarly, if given, sqrtparameter specifies the list of the roots of the parameters, or is a single value which specifies the root of the single value given as a parameter. If parameters are not given, they are assumed to be equal to 1. The Iwahori-Hecke algebra then degenerates to the group algebra of the Coxeter group.

The reason sqrtparameter may have to be given is that certain operations on the algebra require taking such square roots (like the character values of algebras of type E_7, E_8, or two-parameter G_2). Moreover, even if we had wanted to make a standard choice of a square root this would have been impossible because GAP is unable to take the square root of an arbitrary value (such as an indeterminate).

The second form takes as an argument a record which has a field `hecke` and returns the value of this field. This is used to return the Hecke algebra of objects derived from Hecke algebras, such as Hecke elements in various bases.

```    gap> W := CoxeterGroup( "B", 3 );
CoxeterGroup("B", 3)
gap> u := X( Rationals );; u.name := "u";;```

One parameter algebra without and with specifying square roots:

```    gap> H := Hecke( W, u );
Hecke(CoxeterGroup("B", 3),[ u, u, u ],[  ])
gap> H := Hecke( W, u^2, u );
Hecke(CoxeterGroup("B", 3),[ u^2, u^2, u^2 ],[ u, u, u ])
gap> H := Hecke( W, [ u^6, u^4, u^4 ], [ u^3, -u^2, -u^2 ] );
Hecke(CoxeterGroup("B", 3),[ u^6, u^4, u^4 ],[ u^3, -u^2, -u^2 ])```

The parameters do not have to be indeterminates:

```    gap> H := Hecke( W, 9, 3 );
Hecke(CoxeterGroup("B", 3),[ 9, 9, 9 ],[ 3, 3, 3 ])
gap> H := Hecke( W, [ u^6, u^4, u^8] );
Error, Hecke algebra parameters should be equal for conjugate
reflections in Hecke( W, [ u^6, u^4, u^8 ] )) called from main loop
brk> ```

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

## 81.2 HeckeSubAlgebra

`HeckeSubAlgebra( H, r )`

Given an Hecke Algebra H and a set of roots of `Group(H)` given as their index in the roots, return the Hecke sub-algebra generated by the T_s corresponding to these roots. The roots must be simple roots if any parameter is not 1.

As for Subgroup, a subalgebra of a subalgebra is given as a subalgebra of the parent algebra.

```    gap> u := X( Rationals );; u.name := "u";;
gap> H := Hecke( CoxeterGroup( "B", 2 ), u );
Hecke(CoxeterGroup("B", 2),[ u, u ],[  ])
gap> HeckeSubAlgebra( H, [ 1, 4 ] );
Hecke(ReflectionSubgroup(CoxeterGroup("B", 2), [ 1, 2 ]),[ u, u ],
[  ])
gap> HeckeSubAlgebra( H, [ 1, 7 ] );
Error, Generators of a sub-Hecke algebra should be simple reflections
in HeckeSubAlgebra( H, [ 1, 7 ] ) called from main loop
brk> ```

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

## 81.3 Operations and functions for Hecke algebras

`Group`:

returns the Coxeter group from which the Hecke algebra was generated.

`Print`:

prints the Hecke algebra in a form which can be read back into GAP.

`SchurElements`:

see the explicit description in Sections SchurElement and SchurElements.

`CharTable`:

returns the character table of the Hecke algebra. This is a record with exactly the same components as for the corresponding finite Coxeter group but where the component `irreducibles` contains the values of the irreducible characters of the algebra on basis elements T_w where w runs over the elements in the component `classtext`. Thus, the value are now polynomials in the parameters Representations of Iwahori-Hecke algebras.

`Basis`:

the `T` basis is described in the section below. Other bases are described in chapter Kazhdan-Lusztig polynomials and bases.

## 81.4 Construction of Hecke elements of the \$T\$ basis

`Basis( H, "T" )`

Let H be a Iwahori-Hecke algebra. The function `Basis(H,"T")` returns a function which can be used to make elements of the usual `T` basis of the algebra. It is convenient to assign this function with a shorter name when computing with elements of the Hecke algebra. In what follows we assume that we have done the assignment:

```    gap> T := Basis( H, "T" );
function ( arg ) ... end ```

`T( perm )`

Let perm be a permutation which is an element w of the Coxeter group `Group(H)`. This call returns the basis element T_w of H.

`T( perms, coeffs)`

In this form, perms is a vector of permutations and coeffs a vector of coefficients which should be of the same length k. The element text{coeffs}[1] T_{text{perms}[1]} +ldots+ text{coeffs}[k] T_{text{perms}[k]} of H is returned.

`T( list )`

`T( s1, .., sn )`

In the above two forms, s_1,ldots,s_n is a sequence of integers representing generators of the Coxeter group attached to H, or list is a GAP list of such integers. The element T_{s_1}T_{s_2} ldots T_{s_n} is returned.

```    gap> W := CoxeterGroup( "B", 3 );;
gap> u := X( Rationals );; u.name := "u";;
gap> H := Hecke( W, u );;
gap> T := Basis( H, "T" );
function ( arg ) ... end
gap> T( 1, 2 ) = T( [ 1, 2 ] );
true
gap> T( 1, 2 ) = T( PermCoxeterWord( W, [ 1, 2 ] ) );
true
gap> l := [ [], [ 1, 2, 3 ], [ 1 ], [ 2 ], [ 3 ] ];;
gap> pl := List( l, i -> PermCoxeterWord( W, i ) );;
gap> h := T( pl, [ u^100, 1/u^20, 1, -5, 0 ] );
u^100T()+T(1)-5T(2)+0T(3)+u^-20T(1,2,3)
gap> h.elm;
[ (), ( 1,16,13,10, 7, 4)( 2, 8,12,11,17, 3)( 5, 9, 6,14,18,15),
( 1,10)( 2, 6)( 5, 8)(11,15)(14,17),
( 1, 4)( 2,11)( 3, 5)( 8, 9)(10,13)(12,14)(17,18),
( 2, 5)( 3,12)( 4, 7)( 6, 8)(11,14)(13,16)(15,17) ]
gap> h.coeff;
[ u^100, u^(-20), 1, -5, 0 ] ```

The last two lines show that a Hecke element is represented internally by a list of elements of W and the corresponding list of coefficients of the basis elements in H.

Note that the function `T` just creates a Hecke element. In order to have a fast function which does this, the resulting element is not normalized in any way, nor is it even checked if some coefficients are zero or not (see the last line in the above example). A normal form is computed by applying the function `Normalize` to such an element (see below).

The way elements of the Iwahori-Hecke algebra are printed depends on the global variable `PrintHecke` which is a component of the global variable Artin-Tits braid groups). If set to `"GAP"`, they are printed in a way which can be input back in GAP. When you load CHEVIE, the variable is initially set to the string `""`.

```    gap> CHEVIE.PrintHecke := "GAP";
"GAP"
gap> T( pl, [ u^100, 1/u^20, 1, -5, 0 ] );
u^100*T()+T(1)-5*T(2)+0*T(3)+u^-20*T(1,2,3)
gap> CHEVIE.PrintHecke := "";
"" ```

## 81.5 Operations for Hecke elements of the \$T\$ basis

All examples below are with `CHEVIE.PrintHecke=""`.

`Hecke( a )`

returns the Hecke algebra of which a is an element.

`a * b`

The multiplication of two elements given in the `T` basis of the same Iwahori-Hecke algebra is defined, returning a Hecke element expressed in the `T` basis.

```    gap> q := X( Rationals );; q.name := "q";;
gap> H := Hecke( CoxeterGroup( "A", 2 ), q );
Hecke(CoxeterGroup("A", 2),[ q, q ],[  ])
gap> T := Basis( H, "T" );
function ( arg ) ... end
gap> ( T() + T( 1 ) ) * ( T() + T( 2 ) );
T()+T(1)+T(2)+T(1,2)
gap> T( 1 ) * T( 1 );
qT()+(q-1)T(1)
gap> T( 1, 1 ); # the same
qT()+(q-1)T(1) ```

`a ^ i`

A element of the `T` basis with a coefficient whose inverse is still a Laurent polynomial in q can be raised to an integral, positive or negative, power, returning another element of the algebra. An arbitrary element of the algebra can only be raised to a positive power.

```    gap> ( q * T( 1, 2 ) ) ^ -1;
(q^-1-2q^-2+q^-3)T()+(-q^-2+q^-3)T(1)+(-q^-2+q^-3)T(2)+q^-3T(2,1)
gap> ( T( 1 ) + T( 2 ) ) ^ -1;
Error, negative exponent implemented only for single T_w in
<rec1> ^ <rec2> called from
main loop
brk>
gap> ( T( 1 ) + T( 2 ) ) ^ 2;
2qT()+(q-1)T(1)+(q-1)T(2)+T(1,2)+T(2,1) ```

`a / b`

This is equivalent to a* b^{-1}.

`a + b`

`a - b`

Elements of the algebra expressed in the `T` basis can be added or subtracted, giving other elements of the algebra.

```    gap> T( 1 ) + T();
T()+T(1)
gap> T( 1 ) - T( 1 );
0 ```

`Normalize( a )`

normalizes the element a; in particular, terms with zero coefficient are removed.

```    gap> h := T( [ PermCoxeterWord( CoxeterGroup( H ), [ 1 ] ),() ],
>                                                     [ 0, q^100 ] );
q^100T()+0T(1)
gap> Normalize( h );
gap> h;
q^100T() ```

`Print( a )`

prints the element a, using the form initialized in CHEVIE.PrintHecke.

`String( a )`

provides a string containing the same result that is printed with `Print`.

`Coefficient( a, w )`

Returns the coefficient of the Hecke element a on the basis element T_w. Here w can be given either as a Coxeter word or as a permutation.

`AlphaInvolution( a )`

This implements the involution on the algebra defined by T_wmapsto T_{w^{-1}}.

```    gap> AlphaInvolution( T( 1, 2 ) );
T(2,1) ```

`BetaInvolution( a )`

This is only defined if all the parameters of the Iwahori-Hecke algebra are equal, and they are either equal to 1 or all sqrtParameters are bound. If v is the square root of the first parameter, it implements the involution on the algebra defined by vmapsto v^{-1} and T_wmapsto v^{-l(w_0)}T_{w_0w}.

`AltInvolution( a )`

This is only defined if all the parameters of the Iwahori-Hecke algebra are equal, and they are either equal to 1 or all sqrtParameters are bound. If v is the square root of the first parameter, it implements the involution on the algebra defined by vmapsto -v^{-1} and T_wmapsto(-v^{-2})^{l(w)}T_w. Essentially it corresponds to tensoring with the sign representation.

`Frobenius(WF)( a )`

The Frobenius of a Coxeter Coset associated to `CoxeterGroup(Hecke(a))` can be applied to a. For more details see chapter Coxeter cosets.

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

## 81.6 CreateHeckeBasis

`CreateHeckeBasis(basis, ops)`

creates a new basis for Hecke algebras in which to do computations. (The design of this function has benefited from conversation with Andrew Mathas, the author of the package `Specht`).

The first argument basis must be a unique (different from that used for other bases) character string. The second argument ops is a record which should contain at least two fields, `ops.T` and `ops.(basis)` which should contain :

`ops.T`:
a function which takes an element in the basis basis and converts it to the `T` basis.

`ops.(basis)`:
a function which takes an element in the `T` basis and converts it to the basis basis.

After the call to `CreateHeckeBasis`, a new field `(basis)` is added to `HeckeAlgebraOps` which contains a function to create elements of the basis basis. These elements will have the standard operations for Hecke elements: `+`, `-`, `*`, `^`, `=`, `Print`, `Coefficient`, plus all extra operations that the user may have specified in ops. It is thus possible to create a new basis which has extra operations. In addition, for any already created basis y of the algebra, the function `(y)` will have the added capability to convert elements from the basis basis to the y basis. If the user has provided a field `ops.(y)` , the function found there will be used. Otherwise, the function `ops.T` will be used to convert our basis element to the `T` basis, followed by calling the function `(y)` which was given in ops at the time the y basis was created, to convert to the y basis. The following forms of the Basis function will be accepted (as for the `T` basis):

`Basis( H, basis )( perm )`

`Basis( H, basis )( perms, coeffs)`

`Basis( H, basis )( list )`

`Basis( H, basis )( s1, .. , sn )`

One should note, however that for the last two forms only reduced expressions will be accepted in general.

Below is an example where the basis t_w=q^{l(x)/2}T_w is created and used. Here we have set v=q^{1/2}. As an example of an extra operation in ops, we have given a method for `BetaInvolution`. If methods for one of `BetaInvolution`, `AltInvolution` are given they will be automatically called by the generic functions with the same name. Here we have set `BetaInvolution` to use the same method as used by `T` basis elements.

In order to understand the following code, one has to recall that an arbitrary Hecke element is a record; the basis elements are labeled by the Coxeter group elements in the component `elm` and the corresponding coefficients in the component `coeff`. For efficiency reasons, it is necessary to describe the conversion functions on such arbitrary Hecke elements and not just for one basis element T_w or t_w.

```    gap> CreateHeckeBasis( "t", rec(
> T := h->Basis( Hecke(h), "T" )( h.elm, List( [1 .. Length( h.elm )],
>  i->Hecke(h).sqrtParameter[1]^CoxeterLength(
>              CoxeterGroup( Hecke(h) ), h.elm[i] ) *  h.coeff[i] ) ),
>
> t := h->Basis( Hecke(h), "t" )( h.elm, List( [1 .. Length( h.elm )],
>  i->Hecke(h).sqrtParameter[1]^-CoxeterLength(
>               CoxeterGroup( Hecke(h) ), h.elm[i] ) * h.coeff[i] ) ),
>
> BetaInvolution := h->Basis( Hecke( h ),"t")(
>                     HeckeAlgebraOps.T.BetaInvolution(
>                             Basis( Hecke( h ), "T" )( h ) ) ) ) );
gap> v := X( Rationals );; v.name := "v";;
gap> H := Hecke( CoxeterGroup( "A", 3 ), v ^ 2, v );;
gap> h := Basis( H, "t" )( 3, 1, 2 );
t(1,3,2)
gap> h1 := Basis( H, "T")( h );
v^3T(1,3,2)
gap> h2 := Basis( H, "t" )( h1 );
t(1,3,2)
gap> BetaInvolution( h2 );
v^-12t(2,1,3) ```

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

GAP 3.4.4
April 1997