Let *H* be the Iwahori-Hecke algebra of a Coxeter system *(W,S)*, with
quadratic relations *(T _{s}-u_{s,0})(T_{s}-u_{s,1})=0* for

Thus we assume *H* defined over the ring *ℤ[Γ]*, the group algebra
of *Γ* over *ℤ*, and the quadratic relations of *H* associate to
each *s∈ S* a *v _{s}∈Γ^{+}* such that

We define the bar involution on *H* by linearity: on *ℤ[Γ]* we
define it by *∑ _{γ∈Γ}a_{γ}γ=
∑_{γ∈Γ} a_{γ} γ^{-1}* and we extend it to

The basis *C' _{w}* can be computed as follows. We define elements

**CHEVIE** can compute Kazhdan-Lusztig polynomials, left cells, and the
various Kazhdan-Lusztig bases of Iwahori-Hecke algebras (see KL79).
More facilities are implemented for the one-parameter case when all *v _{s}*
have a common value

There is a separate function to compute one-parameter kazhdan-Lusztig
polynomials. From a computational point of view, even this case is quite a
challenge. It seems that the best approach still is by using the recursion
formula in the original article KL79 (which deals with the
one-parameter case, where the above recursion simplifies). One can first
run a number of standard checks on a given pair of elements to see if the
computation of the corresponding polynomial can be reduced to a similar
computation for elements of smaller length, for example. One such check
involves the notion of critical pairs (cf. Alv87): We say that a
pair of elements *w _{1} ≤ w_{2} ∈ W* is critical if

`CriticalPair`

. Whenever the polynomial corresponding to a critical pair is
computed then this pair and the polynomial are stored in the field `.klpol`

of the record of the underlying Coxeter group.
A good example to see how long the programs will take for computations in big Coxeter groups is the following:

gap> W:=CoxeterGroup("D",5);; gap> LeftCells(W);;

which takes *10* seconds cpu time on 3Ghz computer. The computation of all
Kazhdan-Lusztig polynomials for type *F _{4}* takes a bit more than

gap> ReadChv("contr/brbase"); gap> BaseBruhat(W);;

after which the computation of the Bruhat order will be speeded up by a large factor.

However, Alvis' computation of the Kazhdan--Lusztig polynomials of the
Coxeter group of type *H _{4}* in a computer algebra system like

The code for the Kazhdan-Lusztig bases `C`

, `D`

and their primed versions
has been written by Andrew Mathas around 1994, who also contributed to the
initial implementation and to the design of the programs dealing with
Kazhdan-Lusztig bases. He also implemented some other bases, such as the
Murphy basis which can be found in the contributions directory (see also
his `Specht`

package). The extension to the unequal parameters case has
been written by F.Digne and J.Michel around 1999.

The other Kazhdan-Lusztig bases are computed in **CHEVIE** in terms of the
*C'* basis.

**CHEVIE** is able to define automatically the bar and truncation operations
on *ℤ(Γ)* when all parameters are powers of the same indeterminate
*q*, with total order on *Γ* by the power of *q*, or when the
parameters are monomials in some `Mvp`

s, with the lexicographic order. The
bar involution is evaluating a Laurent polynomial at the inverse of the
variables, and truncation is keeping terms of smaller degree than that of
*ν*. It is possible to use arbitrary groups *Γ* by doing the
following steps: first, define the Hecke algebra `H`

. Then, before
defining any of the Kazhdan-Lusztig bases, write functions `H.Bar(p)`

,
`H.PositivePart(p)`

and `H.NegativePart(p)`

which perform the operations
respectively *∑ _{γ∈Γ} a_{γ}γ→
∑_{γ∈Γ} a_{γ}γ^{-1}*,

`p`

of

- KazhdanLusztigPolynomial
- CriticalPair
- KazhdanLusztigCoefficient
- KazhdanLusztigMue
- LeftCells
- LeftCell
- Functions for LeftCells
- W-Graphs
- WGraph
- WGraphToRepresentation
- Hecke elements of the
*C*basis - Hecke elements of the primed
*C*basis - Hecke elements of the
*D*basis - Hecke elements of the primed
*D*basis - Asymptotic algebra
- Lusztigaw
- LusztigAw

`KazhdanLusztigPolynomial( `

`W`, `y`, `w`)

returns the coefficients of the Kazhdan-Lusztig polynomial *P _{y,w}(q)*
attached to the elements

`Hecke(W,q)`

. If one prefers to give as input just two Coxeter words, one
can define a new function as follows (for example):

gap> klpol := function( W, x, y) > return KazhdanLusztigPolynomial(W, EltWord(W, x), EltWord(W, y)); > end; function ( W, x, y ) ... end

We use this function in the following example where we compute the
polynomials *P _{1,w}* for all elements

gap> q := X( Rationals );; q.name := "q";; gap> W := CoxeterGroup( "B", 3 );; gap> el := CoxeterWords( W ); [ [ ], [ 3 ], [ 2 ], [ 1 ], [ 3, 2 ], [ 2, 1 ], [ 2, 3 ], [ 1, 3 ], [ 1, 2 ], [ 2, 1, 2 ], [ 3, 2, 1 ], [ 2, 3, 2 ], [ 2, 1, 3 ], [ 1, 2, 1 ], [ 1, 3, 2 ], [ 1, 2, 3 ], [ 3, 2, 1, 2 ], [ 2, 1, 2, 3 ], [ 2, 3, 2, 1 ], [ 2, 1, 3, 2 ], [ 1, 2, 1, 2 ], [ 1, 3, 2, 1 ], [ 1, 2, 1, 3 ], [ 1, 2, 3, 2 ], [ 3, 2, 1, 2, 3 ], [ 2, 1, 2, 3, 2 ], [ 2, 3, 2, 1, 2 ], [ 2, 1, 3, 2, 1 ], [ 1, 3, 2, 1, 2 ], [ 1, 2, 1, 2, 3 ], [ 1, 2, 1, 3, 2 ], [ 1, 2, 3, 2, 1 ], [ 2, 3, 2, 1, 2, 3 ], [ 2, 1, 2, 3, 2, 1 ], [ 2, 1, 3, 2, 1, 2 ], [ 1, 3, 2, 1, 2, 3 ], [ 1, 2, 1, 2, 3, 2 ], [ 1, 2, 1, 3, 2, 1 ], [ 1, 2, 3, 2, 1, 2 ], [ 2, 1, 2, 3, 2, 1, 2 ], [ 2, 1, 3, 2, 1, 2, 3 ], [ 1, 2, 3, 2, 1, 2, 3 ], [ 1, 2, 1, 2, 3, 2, 1 ], [ 1, 2, 1, 3, 2, 1, 2 ], [ 2, 1, 2, 3, 2, 1, 2, 3 ], [ 1, 2, 1, 2, 3, 2, 1, 2 ], [ 1, 2, 1, 3, 2, 1, 2, 3 ], [ 1, 2, 1, 2, 3, 2, 1, 2, 3 ] ] gap> List( el, w -> Polynomial(Rationals,klpol( W, [], w ))); [ q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q^0, q + 1, q^0, q^0, q^0, q^0, q + 1, q^0, q^0, q + 1, q^0, q^0, q + 1, q + 1, q^0, q + 1, q^0, q + 1, q^0, q^2 + 1, q + 1, q^2 + q + 1, q + 1, q + 1, q^0, q^0, q^2 + 1, q^0, q + 1, q^0 ]

Kazhdan--Lusztig polynomials for critical pairs are stored in the record
component `klpol`

of *W*, which allows the function to work much faster
after the first time it is called.

`CriticalPair( `

`W`, `y`, `w` )

Given elements `y` and `w` in the Coxeter group `W` the function
`CriticalPair`

returns the longest element in the double coset *W _{
L(w)}y W_{ R(w)}*; it is such that the Kazhdan--Lusztig polynomials

gap> W := CoxeterGroup( "F", 4 ); CoxeterGroup("F",4) gap> w := LongestCoxeterElement( W ) * W.generators[1];; gap> CoxeterLength( W, w ); 23 gap> y := EltWord( W, [ 1, 2, 3, 4 ] );; gap> cr := CriticalPair( W, y, w );; gap> CoxeterWord( W, cr); [ 2, 3, 2, 1, 3, 4, 3, 2, 1, 3, 2, 3, 4, 3, 2, 3 ] gap> KazhdanLusztigPolynomial( W, y, w); [ 1, 0, 0, 1 ] gap> KazhdanLusztigPolynomial( W, cr, w); [ 1, 0, 0, 1 ]

`KazhdanLusztigCoefficient( `

`W`, `y`, `w`, `k` )

returns the coefficient of *q ^{k}* in the Kazhdan-Lusztig polynomial

`Hecke(W,q)`

.

gap> W := CoxeterGroup( "B", 4 );; gap> y := [ 1, 2, 3, 4, 3, 2, 1 ];; gap> py := EltWord( W, y ); ( 1,28)( 2,15)( 4,27)( 6,16)( 7,24)( 8,23)(11,20)(12,17)(14,30)(18,31) (22,32) gap> x := [ 1 ];; gap> px := EltWord( W, x ); ( 1,17)( 2, 8)( 6,11)(10,14)(18,24)(22,27)(26,30) gap> Bruhat( W, px, py ); true gap> List([0..3],i->KazhdanLusztigCoefficient( W, px, py, i ) ); [ 1, 2, 1, 0 ]

So the Kazhdan-Lusztig polynomial corresponding to *x* and *y* is
*1+2q+q ^{2}*.

`KazhdanLusztigMue( `

`W`, `y`, `w` )

given elements `y` and `w` in the Coxeter group `W`, this function returns
the coefficient of degree *(l(w)-l(y)-1)/2* of the Kazhdan-Lusztig
polynomial *P _{y,w}*.

Of course, the result of this function could also be obtained by

`KazhdanLusztigCoefficient(W,y,w,(CoxeterLength(W,w)-CoxeterLength(W,y)-1)/2)`

but there are some speed-ups compared to this general function.

`LeftCells( `

`W` [, `i`])

returns a list of records describing left cells of `W` for `Hecke(W,q)`

.
The program uses precomputed data(see GH14) for exceptional types
and for type *A*, so is quite fast for these types (it takes 32 seconds to
compute the 101796 left cells for type *E _{8}*). For other types, left cells
are computed from first principles, thus computing many Kazhdan-Lusztig
polynomials. It takes 10 seconds to compute the left cells of

gap> W := CoxeterGroup( "G", 2 );; gap> LeftCells(W); [ LeftCell<G2: duflo= character=phi{1,0}>, LeftCell<G2: duflo=2 character=phi{2,1}+phi{1,3}'+phi{2,2}>, LeftCell<G2: duflo=1 character=phi{2,1}+phi{1,3}''+phi{2,2}>, LeftCell<G2: duflo=1,2 character=phi{1,6}> ]

Printing such a record displays the character afforded by the left cell and
its Duflo involution; the Duflo involution *r* is printed as a subset `I`

of `[1..W.N]`

such that `r=LongestCoxeterElement(ReflectionSubgroup(W,I))`

,
see DescribeInvolution.

If a second argument `i` is given, the program returns only the left cells
which are in the `i`-th two-sided cell, that is whose character is in the
`i`-th family of `W` (see Families of unipotent characters).

gap> LeftCells(W,1); [ LeftCell<G2: duflo=2 character=phi{2,1}+phi{1,3}'+phi{2,2}>, LeftCell<G2: duflo=1 character=phi{2,1}+phi{1,3}''+phi{2,2}> ]

`LeftCell( `

`W`, `x`)

returns a record describing the left cell of `W` for `Hecke(W,q)`

containing element `x`.

gap> W := CoxeterGroup( "E", 8 );; gap> LeftCell(W, Random(W)); LeftCell<E8: duflo=6,11,82,120 character=phi{2268,30}+phi{1296,33}>

`Size( `

`cell`)

Returns the number of elements of the cell.

gap> W:=CoxeterGroup( "H", 3);; gap> c := LeftCells( W );; gap> List( c, Size); [ 1, 6, 5, 8, 5, 6, 1, 5, 8, 5, 5, 6, 6, 5, 8, 5, 5, 8, 5, 6, 6, 5 ]

`Elements( `

`cell`)

Returns the list of elements of the cell.

The operations `in`

and `=`

are defined for left cells.

returns a list of matrices giving the representation of `Hecke(W,v^2,v)`

on
the left cell `c`.

gap> v := X( Cyclotomics ) ;; v.name := "v";; gap> H := Hecke(W, v^2, v ); Hecke(H3,v^2,v) gap> Representation(c[3],H); [ [ [ -v^0, 0*v^0, 0*v^0, 0*v^0, 0*v^0 ], [ 0*v^0, -v^0, 0*v^0, 0*v^0, v ], [ 0*v^0, 0*v^0, -v^0, v, v ], [ 0*v^0, 0*v^0, 0*v^0, v^2, 0*v^0 ], [ 0*v^0, 0*v^0, 0*v^0, 0*v^0, v^2 ] ], [ [ -v^0, v, 0*v^0, 0*v^0, 0*v^0 ], [ 0*v^0, v^2, 0*v^0, 0*v^0, 0*v^0 ], [ 0*v^0, 0*v^0, v^2, 0*v^0, 0*v^0 ], [ 0*v^0, 0*v^0, v, -v^0, 0*v^0 ], [ 0*v^0, v, v, 0*v^0, -v^0 ] ], [ [ v^2, 0*v^0, 0*v^0, 0*v^0, 0*v^0 ], [ v, -v^0, 0*v^0, 0*v^0, 0*v^0 ], [ 0*v^0, 0*v^0, -v^0, v, 0*v^0 ], [ 0*v^0, 0*v^0, 0*v^0, v^2, 0*v^0 ], [ 0*v^0, 0*v^0, 0*v^0, 0*v^0, -v^0 ] ] ]

Returns a list `l` such that the character of `W` afforded by the left cell
`c` is `Sum(CharTable(W).irreducibles{l})`

.

gap> Character(c[13]); [ 6, 5 ]

See also `WGraph`

below. When `Character(c)`

has been computed, then `c.a`

also has been bound which holds the common value of Lusztig's *a*-function
(see LowestPowerGenericDegrees) for

• The elements of `c`

.

• The irreducible constituents of `Character(c)`

.

Let *H* be the 1-parameter Hecke algebra with parameter *q* associated to
the Coxeter system *(W,S)*. A *W*-graph encodes a representation of *H* of
the kind which is constructed by Kazhdan-Lusztig theory. It consists of a
basis *V* (the vertices of the graph) of a real vector space with a
function *x→ I(x)* from *V* to the subsets of *S* and a function
*μ: V ^{2}→ℝ* (the nonzero values are thus labels for the edges of the
graph). This defines the representation of

T_{s}(x)={ |
| . |

There are two points to *W*-graphs. First, they describe nice, sparse,
integral representations of *H* (and thus of *W* also). Second, they can be
stored very compactly; for example, for the representation of dimension
7168 of the Hecke algebra of type *E _{8}*, a naive implementation would take
more than a gigabyte. The corresponding

*W*-graphs are represented in **CHEVIE** as a pair.

• The first element is a list describing C; its elements are either a set I(x), or an integer n specifying to repeat the previous element n more times.

•
The second element is a list which specifies *μ*. We first describe the
*μ*-list for symmetric *W*-graphs (when *μ(x,y)=μ(y,x)*). There is
one element of the *μ*-list for each non-zero value *m* taken by *μ*,
which consists of a pair whose first element is *m* and whose second
element is a list of lists; if `l`

is one of these lists each pair
`[l[1],l[i]]`

represents an edge `x=l[1],y=l[i]`

such that
*μ(x,y)=μ(y,x)=m*. For non-symmetric *W*-graphs, the first element of
each pair in the *μ*-list is a pair `[m,n]`

and each edge `[x,y]`

obtained from the lists in the second element has to be interpreted as
*μ(x,y)=m* and *μ(y,x)=n*.

Here is an example of graph for a Coxeter group, and the corresponding
representation. Here `v`

is a variable representing the square root of `q`

.

gap> W:=CoxeterGroup("H",3);; gap> WGraph(W,3); [ [ [ 2 ], [ 1, 2 ], [ 1, 3 ], [ 1, 3 ], [ 2, 3 ] ], [ [ -1, [ [ 1, 3 ], [ 2, 4 ], [ 3, 5 ], [ 4, 5 ] ] ] ] ] gap> WGraphToRepresentation(3,last,Mvp("v")); [ [ [ v^2, 0, 0, 0, 0 ], [ 0, -1, 0, 0, 0 ], [ -v, 0, -1, 0, -v ], [ 0, 0, 0, -1, -v ], [ 0, 0, 0, 0, v^2 ] ], [ [ -1, 0, -v, 0, 0 ], [ 0, -1, 0, -v, 0 ], [ 0, 0, v^2, 0, 0 ], [ 0, 0, 0, v^2, 0 ], [ 0, 0, -v, -v, -1 ] ], [ [ v^2, 0, 0, 0, 0 ], [ 0, v^2, 0, 0, 0 ], [ -v, 0, -1, 0, 0 ], [ 0, -v, 0, -1, 0 ], [ 0, 0, 0, 0, -1 ] ] ]

`WGraph( `

`W`, `i` )

*W* should be a finite Coxeter group. Returns the *W*-graph for the *i*-th
representation of the one-parameter Hecke algebra of *W* (or the *i*-th
representation of *W*). For the moment this is only implemented for
irreducible groups of exceptional type *E, F, G, H*.

`WGraph( `

`c` )

*c* should be a left cell for the one-parameter Hecke algebra of a finite
Coxeter group *W*. Returns the corresponding *W*-graph.

`WGraphToRepresentation (`

`r`, `graph`, `v`)

`graph` should be a *W*-graph for some finite Coxeter group *W* of
semisimple rank `r`. The function returns the `r` matrices defining the
representation defined by `graph` of the Hecke algebra for *W* with
parameters *-1* and *v ^{2}*.

gap> W:=CoxeterGroup("H",3);; gap> g:=WGraph(W,3); [ [ [ 2 ], [ 1, 2 ], [ 1, 3 ], [ 1, 3 ], [ 2, 3 ] ], [ [ -1, [ [ 1, 3 ], [ 2, 4 ], [ 3, 5 ], [ 4, 5 ] ] ] ] ] gap> WGraphToRepresentation(3,g,Mvp("v")); [ [ [ v^2, 0, 0, 0, 0 ], [ 0, -1, 0, 0, 0 ], [ -v, 0, -1, 0, -v ], [ 0, 0, 0, -1, -v ], [ 0, 0, 0, 0, v^2 ] ], [ [ -1, 0, -v, 0, 0 ], [ 0, -1, 0, -v, 0 ], [ 0, 0, v^2, 0, 0 ], [ 0, 0, 0, v^2, 0 ], [ 0, 0, -v, -v, -1 ] ], [ [ v^2, 0, 0, 0, 0 ], [ 0, v^2, 0, 0, 0 ], [ -v, 0, -1, 0, 0 ], [ 0, -v, 0, -1, 0 ], [ 0, 0, 0, 0, -1 ] ] ]

`WGraphToRepresentation(`

`H`, `graph`)

`H` should be a one-parameter Hecke algebra for a finite Coxeter group. The
function returns the matrices of the representation defined by `graph` of
*H*.

gap> H:=Hecke(W,[[Mvp("v"),-Mvp("v")^-1]]); Hecke(H3,[[v,-v^-1]]) gap> WGraphToRepresentation(H,g); [ [ [ v, 0, 0, 0, 0 ], [ 0, -v^-1, 0, 0, 0 ], [ -1, 0, -v^-1, 0, -1 ], [ 0, 0, 0, -v^-1, -1 ], [ 0, 0, 0, 0, v ] ], [ [ -v^-1, 0, -1, 0, 0 ], [ 0, -v^-1, 0, -1, 0 ], [ 0, 0, v, 0, 0 ], [ 0, 0, 0, v, 0 ], [ 0, 0, -1, -1, -v^-1 ] ], [ [ v, 0, 0, 0, 0 ], [ 0, v, 0, 0, 0 ], [ -1, 0, -v^-1, 0, 0 ], [ 0, -1, 0, -v^-1, 0 ], [ 0, 0, 0, 0, -v^-1 ] ] ]

returns a function which gives the *C*-basis of the Iwahori-Hecke algebra
`H`. The parameters of `H` should be powers of a single indeterminate or
`Mvp`

s (see the introduction). This basis is defined as follows (see e.g.
Lus85, (5.1)). Let *W* be the underlying Coxeter group. For *x,y ∈
W* let *P _{x,y}* be the corresponding Kazhdan--Lusztig polynomial. If

C_{s} . C_{x} ={ |
| . |

gap> W := CoxeterGroup( "B", 3 );; gap> v := X( Rationals );; v.name := "v";; gap> H := Hecke( W, v^2, v ); Hecke(B3,v^2,v) gap> T := Basis( H, "T" ); function ( arg ) ... end gap> C := Basis( H, "C" ); function ( arg ) ... end gap> T( C( 1 ) ); -vT()+v^-1T(1) gap> C( T( 1 ) ); v^2C()+vC(1)

We can also compute character values on elements in the *C*-basis as
follows:

gap> ref := HeckeReflectionRepresentation( H );; gap> c := CharRepresentationWords(ref, ChevieClassInfo(W).classtext); [ 3*v^0, 2*v^2 - 1, v^8 - 2*v^4, -3*v^12, 2*v^2 - 1, v^4, v^4 - 2*v^2, -v^6, v^4 - v^2, 0*v^0 ] gap> List(ChevieClassInfo(W).classtext, i->HeckeCharValues(C(i),c)); [ 3*v^0, -v - v^(-1), 0*v^0, 0*v^0, -v - v^(-1), 2*v^0, 0*v^0, 0*v^0, v^0, 0*v^0 ]

`Basis( `

`H`, "C'" )

returns a function which gives the *C'*-basis of the Iwahori-Hecke
algebra `H` (see Lus85, (5.1)) The parameters of `H` should be
powers of a single indeterminate or monomials in `Mvp`

's (see the
introduction). This basis is defined by

C for _{x}' := ∑_{y ≤
x}P_{y,x}q_{x}^{-1/2} T_{y} x ∈ W. |

`AltInvolution`

in section "Operations for Hecke elements of the

gap> v := X( Rationals );; v.name := "v";; gap> H := Hecke( CoxeterGroup( "B", 2 ), [v ^4, v^2] );; gap> h := Basis( H, "C'" )( 1 ); #warning: C' basis: v\^2 chosen as 2nd root of v\^4 C'(1) gap> h2 := h * h; (v^2+v^-2)C'(1) gap> Basis( H, "T" )( h2 ); (1+v^-4)T()+(1+v^-4)T(1) gap> Basis(H,"C'")(last); (v^2+v^-2)C'(1)

`Basis( `

`H`, "D" )

returns a function which gives the *D*-basis of the (one parameter generic)
Iwahori-Hecke algebra `H` (see Lus85, (5.1)) of the finite Coxeter
group `W`. This can be defined by

D for every _{x} := v^{-N}C_{xw0}' T_{w0}
x ∈ W, |

`BetaInvolution`

in
section "Operations for Hecke elements of the

gap> W := CoxeterGroup( "B", 2 );; gap> v := X( Rationals );; v.name := "v";; gap> H := Hecke( W, v^2, v ); Hecke(B2,v^2,v) gap> T := Basis( H, "T" ); function ( arg ) ... end gap> D := Basis( H, "D" ); function ( arg ) ... end gap> D( T( 1 ) ); vD(1)-v^2D(1,2)-v^2D(2,1)+v^3D(1,2,1)+v^3D(2,1,2)-v^4D(1,2,1,2) gap> BetaInvolution( D( 1 ) ); C'(2,1,2)

`Basis( `

`H`, "D'" )

returns a function which gives the *D'*-basis of the (one parameter
generic) Iwahori-Hecke algebra `H` of the finite Coxeter group `W` (see
Lus85, (5.1)). This can be defined by

D for every _{x}' :=
v^{-N}C_{xw0} T_{w0} x ∈ W, |

`AltInvolution`

in
section "Operations for Hecke elements of the

gap> W := CoxeterGroup( "B", 2 );; gap> v := X( Rationals );; v.name := "v";; gap> H := Hecke( W, v^2, v ); Hecke(B2,v^2,v) gap> T := Basis( H, "T" ); function ( arg ) ... end gap> Dp := Basis( H, "D'" ); function ( arg ) ... end gap> AltInvolution( Dp( 1 ) ); D(1) gap> Dp( 1 )^3; (v+2v^-1-5v^-5-9v^-7-8v^-9-4v^-11-v^-13)D'()+(v^2+2+v^-2)D'(1)

`AsymptoticAlgebra( `

`W`, `i`)

The asymptotic algebra *A* associated to the algebra *H=*`Hecke(W,q)`

is
an algebra with basis *{t _{x}}_{x∈ W}* and structure constants

The algebra *A* is the direct product of the subalgebras *A _{C}* generated
by the elements

`AsymptoticAlgebra(W,i)`

returns the algebra `a(z)`

is constant over a two-sided cell, equal to the common
value of the `a`

-function attached to the characters of the two-sided cell
(see `Character`

for left cells).

gap> W:=CoxeterGroup("G",2);; gap> A:=AsymptoticAlgebra(W,1); Asymptotic algebra dim.10 gap> b:=A.basis; [ t(2), t(12), t(212), t(1212), t(21212), t(1), t(21), t(121), t(2121), t(12121) ] gap> List(b,x->b*x); [ [ t(2), t(21), t(212), t(2121), t(21212), 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, t(21), t(2)+t(212), t(21)+t(2121), t(212)+t(21212), t(2121) ], [ t(212), t(21)+t(2121), t(2)+t(212)+t(21212), t(21)+t(2121), t(212), 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, t(2121), t(212)+t(21212), t(21)+t(2121), t(2)+t(212), t(21) ], [ t(21212), t(2121), t(212), t(21), t(2), 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, t(1), t(12), t(121), t(1212), t(12121) ], [ t(12), t(1)+t(121), t(12)+t(1212), t(121)+t(12121), t(1212), 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, t(121), t(12)+t(1212), t(1)+t(121)+t(12121), t(12)+t(1212), t(121) ], [ t(1212), t(121)+t(12121), t(12)+t(1212), t(1)+t(121), t(12), 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, t(12121), t(1212), t(121), t(12), t(1) ] ]

`Lusztigaw( `

`W`, `w`)

For `w` an element of the Coxeter groups `W`, this function returns the
coefficients on the irreducible characters of the virtual Character *a _{w}*
defined in Lus85, 5.10.2. This character has the property that the
corresponding almost character is integral and positive.

gap> W:=CoxeterGroup("G",2); CoxeterGroup("G",2) gap> Lusztigaw(W,Reflection(W,1)); [ 0, 0, 1, 0, 1, 1 ] gap> last*List([1..NrConjugacyClasses(W)],i->AlmostCharacter(W,i)); [G2]=<phi{1,3}'>+<phi{2,1}>+<phi{2,2}>

`LusztigAw( `

`W`, `w`)

For `w` an element of the Coxeter groups `W`, this function returns the
coefficients on the irreducible characters of the virtual Character *A _{w}*
defined in Lus85, 5.10.2. This character has the property that the
corresponding almost character is integral and positive.

gap> W:=CoxeterGroup("G",2); CoxeterGroup("G",2) gap> LusztigAw(W,Reflection(W,1)); [ 0, 0, 0, 1, 1, 1 ] gap> last*List([1..NrConjugacyClasses(W)],i->AlmostCharacter(W,i)); [G2]=<phi{1,3}''>+<phi{2,1}>+<phi{2,2}>Previous Up Next

Index

gap3-jm

11 Mar 2019