In this chapter we describe functions for dealing with Iwahori-Hecke algebras associated to Coxeter groups.
Let W be a Coxeter group, with generators S={s1,...,sn}. As before, let m(i,j) denote the order of the product sisj. Let R be a commutative ring with 1 and q1,p1,...,qn,pn be elements in R such that qi=qj and pi=pj whenever si and sj are conjugate (this is the same as requiring that qi=qj and pi=pj whenever the order of sisj is odd). The corresponding Iwahori-Hecke algebra with parameters {qi,pi} is a deformation of the group algebra of W over R where the multiplication of basis elements involves the parameters qi,pi and where the deformation is trivial if all qi are equal to 1 and pi equal to -1.
More precisely, the Iwahori-Hecke algebra H=H(W,R, {qi,pi}) is the associative R-algebra with 1=T1 generated by elements Ts1,...,Tsn subject to the following relations.
|
Since the generators Tsi 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=si1 ... sim= sj1 ... sjm are two reduced expressions of w ∈ W as products of fundamental reflections then the corresponding products of the generators Tsi respectively Tsj will give the same element of H, which we may therefore denote by Tw. Then the elements {Tw | w ∈ W} actually form a free R-basis of H. The multiplication of two arbitrary basis elements Tv,Tw (for v,w ∈ W) is then performed as follows. Choose a reduced expression for v, say v=si1 ... sik. Then Tv is the product of the corresponding generators Tsi hence we are reduced to the case where v=si for some i. In this case, we have
TsiTw = { |
| . |
If all qi are equal and all pi are equal to -1 then 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 Classes and representations for reflection 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 A2.
gap> W := CoxeterGroup( "A", 2 ); CoxeterGroup("A",2)
One-parameter algebra with q=0:
gap> H := Hecke( W, 0 ); Hecke(CoxeterGroup("A",2),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> PrintArray(List(el,x->List(el,y->T(x)*T(y)))); [ [ 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.
Hecke( W , [parameter(s), [sqrtparameter(s)]] )
Constructs the Iwahori-Hecke algebra H of the given Coxeter group. The
following forms are accepted for parameter(s): if para is a single
value, it is replicated to become a list of same length as the number of
generators of W. Otherwise, parameter(s) should be a list of the
same length as the number of generators of W, with possibly unbound
entries (which means it can also be a list of lesser length). There
should be at least one entry bound for each orbit of reflections, and if
several entries are bound for one orbit, they should all be identical.
Now again, an entry for a reflection can be either a single value or a
list of length 2. If it is a list, it is interpreted as the list
[u0,u1] of parameters for that reflection. If it is a single value
q, it is interpreted as [q,-1]
.
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. Thus both Hecke(W)
and Hecke(W,1)
specify the group
algebra of W.
sqrtparameter(s) applies to the case when there is one parameter per
reflection (equivalent to specifying [q,-1]
for that reflection) and
is used to specify a square root of q. It is usually a list like
parameter(s) with at least one bound entry per orbit of reflection, or
it can be a single value which specifies the root of the single value
given as a parameter. The reason sqrtparameter(s) 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 E7, E8, or
two-parameter G2). If such a root is needed but sqrtparameter(s)
has not been specified, then it is filled up with GetRoot(q,2)
(see
the section on utility functions). However, it is useful to specify an
explicit square root, since GetRoot
does not work in all cases, or may
not give the desired root and is generally inconsistent with respect to
various specializations (there cannot exist any function GetRoot
which
will commute with arbitrary specializations).
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) gap> H := Hecke( W, u^2, u ); Hecke(CoxeterGroup("B",3),u^2,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,3) gap> H := Hecke( W, [ u^6, u^4, u^8] ); Error, parameters should be equal for conjugate reflections 3 and 2 in function ( arg ) ... end( CoxeterGroup("B",3), [ [ u^6, -1 ], [ u^4, -1 ], [ u^8, -1 ] ] ) called from function ( arg ) ... end( CoxeterGroup("B",3), [ [ u^6, -1 ], [ u^4, -1 ], [ u^8, -1 ] ] ) called from ChevieDispatcher( "Hecke", arg ) called from Hecke( W, [ u ^ 6, u ^ 4, u ^ 8 ] ) called from main loop brk>
This function requires the package "chevie" (see RequirePackage).
HeckeSubAlgebra( H, r )
Given an Hecke Algebra H and a set of reflections of Group(H)
given as their index in the reflections, return the Hecke sub-algebra
generated by the Ts corresponding to these reflections. The
reflections must be generating reflections if the Hecke algebra is not
the group algebra of W.
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) gap> HeckeSubAlgebra( H, [ 1, 4 ] ); Hecke(ReflectionSubgroup(CoxeterGroup("B",2), [ 1, 2 ]),u) gap> HeckeSubAlgebra( H, [ 1, 7 ] ); Error, Generators of a sub-Hecke algebra should be simple reflections in function ( H, subW ) ... end( Hecke(CoxeterGroup("B",2),u), [ 1, 7 ] ) called from ChevieDispatcher( "HeckeSubAlgebra", arg ) called from HeckeSubAlgebra( H, [ 1, 7 ] ) called from main loop brk>
This function requires the package "chevie" (see RequirePackage).
83.3 Operations and functions for Hecke algebras
Group
:
Print
:SchurElements
:
CharTable
:irreducibles
contains
the values of the irreducible characters of the algebra on basis
elements Tw where w runs over the elements in the component
classtext
. Thus, the value are now polynomials in the parameters
of the algebra. For more details see the chapter Representations
of Iwahori-Hecke algebras.
Basis
:T
basis is described in the section below. Other bases
are described in chapter Kazhdan-Lusztig polynomials and bases.
83.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( w )
Here w is an element of the Coxeter group Group(H)
. This call
returns the basis element Tw of H.
T( 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]*T(elts[i]))
of H is returned.
T( list )
T( s1, .., sn )
In the above two forms, the GAP list list or the GAP list
[s1,..,sn]
represents the Coxeter word for an element w of
Group(H)
. The basis element Tw is returned (actually the call works
even if the word [s1,..,sn]
is not reduced and the element
Ts1... Tsn is returned also in that case).
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( EltWord( W, [ 1, 2 ] ) ); true gap> T(1,1); uT()+(u-1)T(1) gap> l := [ [], [ 1, 2, 3 ], [ 1 ], [ 2 ], [ 3 ] ];; gap> pl := List( l, i -> EltWord( 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
record CHEVIE.PrintHecke
. If it is set to
CHEVIE.PrintHecke:=rec(GAP:=true)
, they are printed in a way which can be
input back in GAP. When you load CHEVIE, the record PrintHecke
initially
set to rec()
.
gap> CHEVIE.PrintHecke:=rec(GAP:=true);; 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:=rec();;
These functions require the package "chevie" (see RequirePackage).
83.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) 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, inverse implemented only for single T_w in h.operations.inverse( h ) called from^ 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( [ EltWord( Group( 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 Tw. Here w can be given either as a Coxeter word or as an element of the Coxeter group.
AlphaInvolution( a )
This implements the involution on the algebra defined by Tw→ Tw-1.
gap> AlphaInvolution( T( 1, 2 ) ); T(2,1)
BetaInvolution( a )
This is only defined when the Kazhdan-Lusztig bases of the Hecke algebra can be defined. It implements the involution on the algebra defined by x→\overline x on coefficients and and Tw→ qw0-1Tw0w.
AltInvolution( a )
This is only defined when the Kazhdan-Lusztig bases of the Hecke algebra can be defined. It implements the involution on the algebra defined by x→\overline x on coefficients and Ts→ -qsTs. Essentially it corresponds to tensoring with the sign representation.
Frobenius(WF)( a )
The Frobenius of a Coxeter Coset associated to Group(Hecke(a))
can
be applied to a. For more details see chapter Coxeter cosets.
These functions require the package "chevie" (see RequirePackage).
83.6 Specialization from one Hecke algebra to another
Specialization( H1, H2, f)
H1 and H2 should be Hecke algebras of the same group, and f should be a function which applied to the parameters of H1 gives those of H2. The result is a function which can transport Hecke elements from H1 to H2 by the specialization map induced by f. As an example below, we compute the so-called "Kazhdan-Lusztig basis" of the symmetric group by specializing that of the Hecke algebra.
gap> q:=X(Rationals);;q.name:="q";; gap> W:=CoxeterGroup("A",2);H1:=Hecke(W,q^2);H2:=Hecke(W); CoxeterGroup("A",2) Hecke(CoxeterGroup("A",2),q^2) Hecke(CoxeterGroup("A",2)) gap> T:=Basis(H1,"T");Cp:=Basis(H1,"C'"); function ( arg ) ... end #warning: C' basis: q chosen as 2nd root of q\^2 function ( arg ) ... end gap> f:=function(x) > if IsPolynomial(x) then return Value(x,1); > else return x; fi; > end; function ( x ) ... end gap> s:=Specialization(H1,H2,f); function ( t ) ... end gap> CoxeterWords(W); [ [ ], [ 2 ], [ 1 ], [ 2, 1 ], [ 1, 2 ], [ 1, 2, 1 ] ] gap> List(last,x->s(T(Cp(x)))); [ T(), T()+T(2), T()+T(1), T()+T(1)+T(2)+T(2,1), T()+T(1)+T(2)+T(1,2), T()+T(1)+T(2)+T(1,2)+T(2,1)+T(1,2,1) ]
T(Cp(x))
, not Cp(x)
:Specialization
method. Rather, one has to convert to
basis T
first, which has a specialization method.
This function requires the package "chevie" (see RequirePackage).
CreateHeckeBasis(basis, ops, heckealgebraops)
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
:T
basis.
ops.(basis)
:T
basis
and converts it to the basis basis.
The third arguments should be the field .operations
of some Hecke
algebra. After the call to CreateHeckeBasis
, a new field (basis)
is added to heckealgebraops
which contains a function to create
elements of the basis basis. Thus all Hecke algebras which have the
same field .operations
will have the new basis.
The elements of the new basis 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 tw=ql(x)/2Tw is created and
used. Here we have set v=q1/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 Tw or tw.
gap> v := X( Rationals );; v.name := "v";; gap> H := Hecke( CoxeterGroup( "A", 3 ), v ^ 2, v );; gap> CreateHeckeBasis( "t", rec( > T := h->Basis( Hecke(h), "T" )( h.elm, List( [1 .. Length( h.elm )], > i->Hecke(h).rootParameter[1]^CoxeterLength( > Group( Hecke(h) ), h.elm[i] ) * h.coeff[i] ) ), > > t := h->Basis( Hecke(h), "t" )( h.elm, List( [1 .. Length( h.elm )], > i->Hecke(h).rootParameter[1]^-CoxeterLength( > Group( Hecke(h) ), h.elm[i] ) * h.coeff[i] ) ), > > BetaInvolution := h->Basis( Hecke( h ),"t")( > H.operations.T.BetaInvolution( > Basis( Hecke( h ), "T" )(h)))),H.operations ); 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