Let *H* be the Hecke algebra of the Coxeter group *W* with Coxeter
generating set *S*, and let *I* be a subset of *S*. Let *χ* be a
one-dimensional character of the parabolic subalgebra *H _{I}* of

The module action of an generator *T _{s}* of

T_{s}. MT_{w}={ |
| . |

Kazhdan-Lusztig bases of an Hecke module are also defined in the same
circumstances when Kazhdan-Lusztig bases of the algebra can be defined,
but only the case of the base `C'`

for *χ* the sign character has
been implemented for now.

- Construction of Hecke module elements of the
*MT*basis - Construction of Hecke module elements of the primed
*MC*basis - Operations for Hecke module elements
- CreateHeckeModuleBasis

`ModuleBasis( `

`H`, "MT" [, `I` [,`chi`]] )

`H` should be an Iwahori-Hecke algebra of a Coxeter group `W` with
Coxeter generating set `S`, `I` should be a subset of `S` (specified by
a list of the names of the generators in `I`), and `chi` should be a
one-dimensional character of the parabolic subalgebra of `H` determined
by `I`, represented by the list of its values on *{T _{s}}_{s∈ I}* (if

The result is a function which can be used to make elements of the `MT`

basis of the Hecke module associated to `I` and `chi`.

If omitted, `I` is assumed to be the first `W.semiSimpleRank-1`

generators of *W* (this makes sense for an affine Weyl group where they
generate the corresponding linear Weyl group), and `chi` is taken to be
equal to *-1* (which specifies the sign character of *H*).

It is convenient to assign this function with a shorter name when computing with elements of the Hecke module. In what follows we assume that we have done the assignment:

gap> W:=CoxeterGroup("A",2);;Wa:=Affine(W);; gap> q:=X(Rationals);;q.name:="q";; gap> H:=Hecke(Wa,q); Hecke(~A2,q) gap> MT:=ModuleBasis(H,"MT"); function ( arg ) ... end

`MT( `

`w` )

Here `w` is an element of the Coxeter group `Group(H)`

. The basis
element *MT _{w}* is returned if

`MT( `

`elts`, `coeffs`)

In this form, `elts`

is a list of elements of `Group(H)`

and `coeffs`

a
list of coefficients which should be of the same length `k`

. The
element `Sum([1..k],i->coeffs[i]*MT(elts[i]))`

is returned.

`MT( `

`list` )

`MT( `

`s1`, .., `sn` )

In the above two forms, the **GAP3** list `list` or the **GAP3** list
`[`

represents the Coxeter word for an element `s1`,..,`sn`]`w` of
`Group(H)`

. The basis element *MT _{w}* is returned if

The way elements of the Hecke module are printed depends on
`CHEVIE.PrintHecke`

. If `CHEVIE.PrintHecke=rec(GAP:=true)`

, they are
printed in a way which can be input back in **GAP3**. When you load **CHEVIE**,
the `PrintHecke`

is initially set to `rec()`

.

`ModuleBasis( `

`H`, "MC'" [, `I`] )

`H` should be an Iwahori-Hecke algebra with all parameters a power of
the same indeterminate of a Coxeter group `W` with Coxeter generating
set `S` and `I` should be a subset of `S` (specified by a list of the
names of the generators in `I`). The character `chi` does not have to
be specified since in this case only `chi``=-1`

has been implemented.

If omitted, `I` is assumed to be the first `W.semiSimpleRank-1`

generators of *W* (this makes sense for an affine Weyl group where they
generate the corresponding linear Weyl group).

The result is a function which can be used to make elements of the
`MC'`

basis of the Hecke module associated to `I` and the sign
character. In this particular case, the *MC'* basis can be
defined for an reduced-*I* element *w* in terms of the *MT* basis by
*MC' _{w}=C'_{w} MT_{1}*.

gap> H:=Hecke(Wa,q^2); Hecke(~A2,q^2) gap> MC:=ModuleBasis(H,"MC'"); #warning: MC' basis: q chosen as 2nd root of q\^2 function ( arg ) ... end

`+`

,`-`

:

one can add or subtract two Hecke module elements.

:`Basis`(`x`)

this call will convert Hecke module element`x`to basis

. With the same initializations as in the previous sections, we have:`Basis`

gap> MT:=ModuleBasis(H,"MT");; gap> MC(MT(1,2,3)); -MC'()+qMC'(3)-q^2MC'(1,3)-q^2MC'(2,3)+q^3MC'(1,2,3)

`*`

:

one can multiply on the left an Hecke module element by an element of the corresponding Hecke algebra. With the same initializations as in the previous sections, we have:

gap> H:=Hecke(Wa,q); Hecke(~A2,q) gap> MT:=ModuleBasis(H,"MT");; gap> T:=Basis(H,"T"); function ( arg ) ... end gap> T(1)*MT(1,2,3); qMT(2,3)+(q-1)MT(1,2,3)

`CreateHeckeModuleBasis(`

`basis`, `ops`, `algebraops`)

This function is completely parallel to the function `CreateHeckeBasis`

.
See the description of this last function. The only difference is that
it is not

which is required to be bound, but `ops`.T

which
should contain a function which takes an element in the basis `ops`.MT`basis`
and converts it to the `MT`

basis.

gap3-jm

11 Mar 2019