In this chapter we describe functions for dealing with IwahoriHecke algebras associated to Coxeter groups.
Let W,S be a Coxeter system, where W is generated by S and denote by m_{s,t} the order of the product st for s,t∈ S. Let R be a commutative ring with 1 and for s∈ S let u_{s,0},u_{s,1} be elements in R such that u_{s,0}=u_{t,0} and u_{s,1}=u_{t,1} whenever s,t∈ S are conjugate in W (this is the same as requiring that u_{s,i}=u_{t,i} whenever m_{s,t} is odd). The corresponding IwahoriHecke algebra with parameters {u_{s,i}} is a deformation of the group algebra of W over R. More precisely, H=H(W,R, {u_{s,i}}) is the unitary associative Ralgebra generated by elements {T_{s}}_{s∈ S} subject to the relations:

If u_{s,0}=1 and u_{s,1}=1 for all s then the quadratic relations become T_{s}^{2}=1 and the deformation of the group algebra is trivial.
Since the generators T_{s} 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_{1} ... s_{m}= t_{1} ... t_{m} are two reduced expressions of w ∈ W as products of elements of S, then the corresponding products of the generators T_{si} respectively T_{tj} will give the same element of H, which we may therefore denote by T_{w}. We have T_{1}=1.
If one of u_{s,0} or u_{s,1} is invertible in R, for example u_{s,1}, then by changing the generators to T_{s}/u_{s,1}, and setting q_{s}=u_{s,0}/u_{s,1}, the braid relations do no change (since when m_{s,t} is odd we have u_{s,i}=u_{t,i}) but the quadratic relations become (T_{s}q_{s})(T_{s}+1)=0. This last form is the most common form considered in the literature. Another common form in the context of KazhdanLusztig theory is obtained by scaling the generators as T_{s}/√u_{s,0}u_{s,1}, giving rise to the quadratic relations (T_{s}v_{s})(T_{s}+v_{s}^{1})=0 where v_{s}=√q_{s}. The general form of parameters provided by CHEVIE is a special case of general cyclotomic Hecke algebras, and can be useful in many contexts.
The second form above, or for some algebras the character table in the
first form, require a square root of u_{s,0}u_{s,1}. CHEVIE provides a
way to specify it with the field .rootParameter
which can be given when
constructing the algebra. If not given a root is automatically extracted
when needed by the function RootParameter
. Note however that sometimes an
explicit choice of root is necessary which cannot be automatically
determined.
There is a universal choice for R and {u_{s,i}}: Let {u_{s,i}}_{s∈ S,i∈{0,1}} be indeterminates such that u_{s,i}=u_{t,i} whenever m_{s,t} is odd, and let A_{0}=ℤ[u_{s,i}]_{s,i} be the corresponding polynomial ring. Then H_{0}:=H(W,A_{0},{u_{s,i}}) is called the generic IwahoriHecke algebra associated with W. Another algebra H(W,R,{v_{s,i}}) can be obtained by specialization from H_{0}: There is a unique ring homomorphism f:A_{0} → R such that f(u_{s,i})=v_{s,i} for all i. Then we can view R as an A_{0}module via f and we can identify H(W,R,{v_{s,i}})=R ⊗_{A0} H_{0}.
The elements {T_{w}  w ∈ W} actually form an Rbasis of H if one of the u_{s,i} is invertible for all s. The structure constants in that basis is obtained as follows. To multiply T_{v} by T_{w}, choose a reduced expression for v, say v=s_{1} ... s_{k} and apply inductively the formula:
T_{s}T_{w} = { 
 . 
Hecke(W,q)
. Certain
invariants of the irreducible characters of this algebra play a special
role in the representation theory of the underlying finite Coxeter groups,
namely the a and Ainvariants already occured in chapter Classes and
representations for reflection groups (see LowestPowerGenericDegrees,
JInductionTable). For basic properties of IwahoriHecke algebras and
their relevance to the representation theory of finite groups of Lie type,
see for example CR87, Sections 67 and 68.
In the following example, we compute the multiplication table for the 0IwahoriHecke algebra associated with the Coxeter group of type A_{2}.
gap> W := CoxeterGroup( "A", 2 ); CoxeterGroup("A",2)
Oneparameter algebra with q=0:
gap> H := Hecke( W, 0 ); Hecke(A2,0)
Create the Tbasis:
gap> T := Basis( H, "T" ); function ( arg ) ... end gap> el := CoxeterWords( W ); [ [ ], [ 2 ], [ 1 ], [ 2, 1 ], [ 1, 2 ], [ 1, 2, 1 ] ]
Multiply any two Tbasis 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 work with algebras with arbitrary parameters. We will see that this also works on the level of characters and representations.
Hecke( W [, parameter, [rootparameter]] )
Constructs the IwahoriHecke algebra H of the given Coxeter group. The
following forms are accepted for parameter: if parameter is a single
value, it is replicated to become a list of same length as the number of
generators of W. Otherwise, parameter 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 [u_{0},u_{1}] of parameters for that
reflection. If it is a single value q, it is interpreted as [q,1]
.
If parameter are not given, they are assumed to be equal to 1. The
IwahoriHecke 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.
rootparameter is used to specify a square root of u_{0}u_{1} (a square
root of q when [u_{0},u_{1}] are [q,1]
). It is usually a list like
parameter with at least one bound entry per orbit of reflection, or it
can be a single value which is replicated to become a list of same length
as the number of generators of W. If not given then rootparameter is
computed upon need by calling the function RootParameter
(see
RootParameter).
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(B3,u) gap> H := Hecke( W, u^2, u ); Hecke(B3,u^2,u) gap> H := Hecke( W, [ u^6, u^4, u^4 ], [ u^3, u^2, u^2 ] ); Hecke(B3,[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(B3,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, u^4, u^8 ] ) called from function ( arg ) ... end( CoxeterGroup("B",3), [ u^6, u^4, u^8 ] ) called from Hecke( W, [ u ^ 6, u ^ 4, u ^ 8 ] ) called from main loop brk>
All operations for cyclotomic Hecke algebras are defined for IwahoriHecke algebras, in particular :
Group
:
Print
:FormatGAP
for
a form which can be read back into GAP3.
SchurElements
:CharTable
: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
of the algebra. For more details see the chapter Representations
of IwahoriHecke algebras.
Basis
:T
basis is described in the section below. Other bases
are described in chapter KazhdanLusztig polynomials and bases.
H should be an IwahoriHecke algebra. If its parameters are u_{0}, u_{1}
for the ith generating reflection, this function returns a square root
of u_{0}u_{1}. These roots are necessary for certain operations on the
algebra, like the character values of algebras of type E_{7}, E_{8}, or
twoparameter G_{2}. If rootparameters
have been given at the time of the
definition of the Hecke algebra (see Hecke for Coxeter groups) then they
are returned. If they had not been specified, then if u_{0}u_{1}=1 then 1
is returned, else the square root is computed as GetRoot(
u_{0}u_{1})
(see GetRoot). It is useful to specify explicit square roots, since
GetRoot
does not work in all cases, or may yield the negative of 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("A",2);; gap> q:=X(Rationals);;q.name:="q";; gap> H:=Hecke(W,q^2,q); Hecke(A2,q^2,q) gap> RootParameter(H,1); q gap> H:=Hecke(W,q^2); Hecke(A2,q^2) gap> RootParameter(H,1); q gap> H:=Hecke(W,3); Hecke(A2,3) gap> RootParameter(H,1); E(12)^7+E(12)^11
RootParameter(H, w)
If w is an element of Group(H)
then the function returns the product of
the RootParameter
s for the reflections in a reduced expression for w.
gap> H:=Hecke(W,q^2,q); Hecke(A2,q^2,q) gap> RootParameter(H,LongestCoxeterElement(W)); q^3
Given an Hecke Algebra H and a set of reflections of Group(H)
given
as their index in the reflections of Parent(Group(H))
(see
ReflectionSubgroup), return the Hecke subalgebra generated by the T_{s}
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(B2,u) gap> HeckeSubAlgebra( H, [ 1, 4 ] ); Hecke(B2,u) gap> HeckeSubAlgebra( H, [ 1, 7 ] ); Error, Generators of a subHecke algebra should be simple reflections \ in function ( H, subW ) ... end( Hecke(B2,u), [ 1, 7 ] ) called from HeckeSubAlgebra( H, [ 1, 7 ] ) called from main loop brk>
Let H be a IwahoriHecke 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 T_{w} 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 GAP3 list list or the GAP3 list
[s1,..,sn]
represents the Coxeter word for an element w of
Group(H)
. The basis element T_{w} is returned (actually the call works
even if the word [s1,..,sn]
is not reduced and the element
T_{s1}... T_{sn} 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()+(u1)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)+u^20T(1,2,3) gap> h.elm; [ (), ( 1, 4)( 2,11)( 3, 5)( 8, 9)(10,13)(12,14)(17,18), ( 1,10)( 2, 6)( 5, 8)(11,15)(14,17), ( 1,16,13,10, 7, 4)( 2, 8,12,11,17, 3)( 5, 9, 6,14,18,15) ] gap> h.coeff; [ u^100, 5, 1, u^(20) ]
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.
The way elements of the IwahoriHecke algebra are printed depends on
CHEVIE.PrintHecke
. If it is set to
CHEVIE.PrintHecke:=rec(GAP:=true)
, they are printed in a way which can
be input back in GAP3. When you load CHEVIE, the record PrintHecke
initially set to rec()
. To go on from the above example:
gap> CHEVIE.PrintHecke:=rec(GAP:=true);; gap> h; u^100*T()+T(1)5*T(2)+u^20*T(1,2,3) gap> CHEVIE.PrintHecke:=rec();; gap> h; u^100T()+T(1)5T(2)+u^20T(1,2,3)
All examples below are with CHEVIE.PrintHecke=""
.
Hecke( a )
:
a * b
:T
basis of the same
IwahoriHecke 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(A2,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()+(q1)T(1) gap> T( 1, 1 ); # the same qT()+(q1)T(1)
a ^ i
: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^12q^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 <rec1> ^ <rec2> called from main loop brk> gap> ( T( 1 ) + T( 2 ) ) ^ 2; 2qT()+(q1)T(1)+(q1)T(2)+T(1,2)+T(2,1)
a / b
:a* b^1
.
a + b
a  b
: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
Print( a )
:
String( a )
:Print
.
Coefficient( a, w )
:AlphaInvolution( a )
:
gap> AlphaInvolution( T( 1, 2 ) ); T(2,1)
BetaInvolution( a )
:AltInvolution( a )
:Frobenius(WF)( a )
:Group(Hecke(a))
can
be applied to a. For more details see chapter Frobenius.
gap> W:=CoxeterGroup("D",4);WF:=CoxeterCoset(W,(1,2,4)); CoxeterGroup("D",4) 3D4 gap> H:=Hecke(W,X(Rationals)); Hecke(D4,q) gap> T:=Basis(H,"T"); function ( arg ) ... end gap> Frobenius(WF)(T(1)); T(4) gap> Frobenius(WF)(T(1),1); T(2)
Representation(a)( n )
:H:=Hecke(a)
. n
can be a representation of H, or an integer specifying the nth
representation of H.
gap> Representation(T(1,2),2); [ [ q, 0*q^0, 0*q^0 ], [ 0*q^0, q, 0*q^0 ], [ q^2  q, q + 1, q^0 ] ] gap> r:=Representations(H,2); [ [ [ q  1, q^0, 0*q^0 ], [ q, 0*q^0, 0*q^0 ], [ q^2 + q, q  1, q^0 ] ], [ [ 0*q^0, q^0, 0*q^0 ], [ q, q  1, 0*q^0 ], [ 0*q^0, 0*q^0, q^0 ] ], [ [ q^0, 0*q^0, 0*q^0 ], [ 0*q^0, 0*q^0, q^0 ], [ 0*q^0, q, q  1 ] ], [ [ 0*q^0, q^0, 0*q^0 ], [ q, q  1, 0*q^0 ], [ 0*q^0, 0*q^0, q^0 ] ] ] gap> Representation(T(1,2),r); [ [ q, 0*q^0, 0*q^0 ], [ 0*q^0, q, 0*q^0 ], [ q^2  q, q + 1, q^0 ] ]
returns the class polynomials of the Hecke element h of the Hecke algebra
H with respect to representatives reps of minimal length in the
conjugacy classes of the Coxeter group Group(H). Such minimal length
representatives are given by the function
ChevieClassInfo(Group(H)).classtext
. These polynomials have the following
property. Given the class polynomials p corresponding to h and the
matrix X of the values of the irreducible characters of the IwahoriHecke
algebra on T_{w} (for w in reps), then the product X*p
is the list
of values of the irreducible characters on the element h of the
IwahoriHecke algebra.
gap> u := X( Rationals );; u.name := "u";; gap> W := CoxeterGroup( "A", 3 ); CoxeterGroup("A",3) gap> H := Hecke( W, u );; gap> h := Basis( H, "T" )( LongestCoxeterElement( W ) ); T(1,2,1,3,2,1) gap> cp := HeckeClassPolynomials( h ); [ 0*u^0, 0*u^0, u^2, u^3  2*u^2 + u, u^3  u^2 + u  1 ] gap> CharTable( H ).irreducibles * cp; [ u^0, u^2, 2*u^3, u^4, u^6 ]
So, the entries in this list are the values of the irreducible characters on the basis element corresponding to the longest element in the Coxeter group.
The class polynomials were introduced in GP93.
h is an element of an IwahoriHecke algebra (expressed in any basis)
and irreds is a set of irreducible characters of the algebra (given as
vectors). HeckeCharValues
returns the values of irreds on the
element h (the method used is to convert to the T
basis, and then use
HeckeClassPolynomials
). If irreds is not given, all character values
are returned.
gap> q := X( Rationals );; q.name := "q";; gap> H := Hecke( CoxeterGroup( "B", 2 ), q ^ 2, q );; gap> HeckeCharValues( Basis( H, "C'" )( 1, 2, 1 ) ); [ q  q^(1), q + q^(1), 0*q^0, q^3 + 2*q + 2*q^(1) + q^(3), 0*q^0 ]
See also HeckeClassPolynomials.
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 socalled ``KazhdanLusztig 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(A2,q^2) Hecke(A2) 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) ]
Note that in the above example we specialize T(Cp(x))
, not Cp(x)
:
since KazhdanLusztig bases do not, strictly speaking, exist for the
symmetric group algebra, it does not make sense to specialize them so they
have no Specialization
method. Rather, one has to convert to basis T
first, which has a specialization method.
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 )( w )
Basis( H, basis )( elts, 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(w)/2}T_{w} is created and
used; we assume the equal parameter case. As an example of an extra
operation in ops, we have given a method for BetaInvolution
, which just
dos the map w→ w w_{0} for the t basis. If methods for one of
BetaInvolution
, AltInvolution
are given they will be automatically
called by the generic functions with the same name.
In order to understand the following code, one has to recall that an
arbitrary Hecke element is a record representing a sum of basis elements;
it contains a list of Coxeter group elements in the component elm
and the
corresponding list of coefficients in the component coeff
. For efficiency
reasons, it is desirable to describe how to convert to another base such
general Hecke elements and not just 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>RootParameter(Hecke(h),h.elm[i])^1*h.coeff[i])), > t := h>Basis( Hecke(h), "t" )(h.elm, List( [1 .. Length( h.elm )], > i>RootParameter(Hecke(h), h.elm[i])*h.coeff[i])), > BetaInvolution := h>Basis(Hecke(h),"t")(List(h.elm, > x>x*LongestCoxeterElement(Group(Hecke(h)))),h.coeff)), > H.operations);
Now we setup the algebra using v=q^{1/2} and use the basis t
.
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 ); t(2,1,3)
One can defined parameterized bases, that is bases whose behavior depend on some parameter(s). As an example we will define the basis t(i)_{w}=q^{i l(w)}T_{w}, where we assume that 2i is an integer. We first write the example and then comment its differences from the previous case.
gap> CreateHeckeBasis( "ti", 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])*2*h.i)*h.coeff[i] ) ), > extraFields:=["i"], > ti := function(h,extra) return Basis( Hecke(h), "ti" ) > ( h.elm, List( [1 .. Length( h.elm )], > i>Hecke(h).rootParameter[1]^(CoxeterLength( > Group( Hecke(h) ), h.elm[i])*2*extra.i)*h.coeff[i]), extra); > end, > BetaInvolution:=h>Basis(Hecke(h),"ti")( > H.operations.T.BetaInvolution(Basis(Hecke(h),"T")(h)), > HeckeEltOps.GetExtra(h)), > FormatBasis:=h>SPrint("t[",h.i,"]")), > H.operations );
Here each Hecke element h
has a field h.i
holding the value of i
.
This is used in converting the element to basis T
. The field i
must be
copied from one object to the other during various operations on Hecke
elements. For CHEVIE to know which fields must be copied, the list of
such fields must be declared, which is done by the above assignment
extraFields:=["i"]
. A record containing the extra fields must be
passed as the last argument of each call of the Basis
function, so it
knows which information to put in the built Hecke elements; thus the call
take one of the forms
Basis( H, basis )( w, extra )
Basis( H, basis )( elts, coeffs, extra)
Basis( H, basis )( list, extra )
Basis( H, basis )( s1, .. , sn, extra )
The function ti
to convert to the basis ti
requires also a record
argument containing the extra information, which it passes to the second
form above. The function BetaInvolution
illustrates how one can extract
this extra information record from a Hecke element using the function
HeckeEltOps.GetExtra(h))
; we also used a different method to compute the
BetaInvolution
, delegating the computation to basis T
instead of doing
it directly. Finally the function FormatBasis
, if given, produces a
parameterized printing of a basis element. Here is how one can use the
above definitions:
gap> v := X( Rationals );; v.name := "v";; gap> H := Hecke( CoxeterGroup( "A", 3 ), v ^ 2, v );; gap> t:=function(arg) Add(arg,rec(i:=1/2)); > return ApplyFunc(Basis(H,"ti"),arg);end; function ( arg ) ... end
Here the function t
does exactly the same as Basis(H,"t")
in the
gap> h := t( 3, 1, 2 ); t[1/2](1,3,2) gap> h1 := Basis( H, "T")( h ); v^3T(1,3,2) gap> h2 := t( h1 ); t[1/2](1,3,2) gap> BetaInvolution( h2 ); t[1/2](2,1,3)
The point is that one can now just as easily define similar functions for
other values of i
.
gap3jm