The ordinary complex character table of any finite Coxeter group is
computed in CHEVIE using the function `CharTable`

. This command first
checks whether or not *W* is irreducible. For each irreducible Coxeter
group a character table record is computed either using recursive
formulas (for the classical types: these functions are part of **GAP**
and described in detail in~Pfe94a) or read into the system from a
library file (for the exceptional types: the tables can be found in the
Cambridge ATLAS CCN85, for example). Thus, character tables can
be obtained quickly even for very large groups (e.g., *E_8*) since they
are obtained via the classification and special algorithms or stored
tables for irreducible groups. The above record is a usual character
table record as defined in **GAP**, but with some additional components.

It is important to note that the conjugacy classes and the irreducible
characters of a finite Coxeter group each have a canonical labeling by
certain combinatorial objects, and that such labelings are contained in a
consistent way in the tables of CHEVIE. For the classes, these are
partitions, pairs of partitions, or Carter's admissible diagrams
Car72. For the characters, these are again partitions, pairs of
partitions, or pairs of two integers *(n,e)* where *n* is the degree of
the character and *e* is the smallest symmetric power of the natural
reflection representation containing the given character as a
constituent. This information is obtained by using the functions
`ChevieClassInfo`

and `ChevieCharInfo`

. It is printed automatically when
you display the character table in **GAP**.

The prototype for this is the symmetric group *{mathfrak S}_{n+1}* (type
*A_n*) where the classes and characters are parametrized by partitions of
*n+1*.

gap> W := CoxeterGroup( "A", 3 );; gap> Display( CharTable( W )); W( A3 ) 2 3 2 3 . 2 3 1 . . 1 . 1111 211 22 31 4 2P 1111 1111 1111 31 22 3P 1111 211 22 1111 4 1111 1 -1 1 1 -1 211 3 -1 -1 . 1 22 2 . 2 -1 . 31 3 1 -1 . -1 4 1 1 1 1 1

Recall that our Coxeter groups acts a reflection group on the real vector
space *V* (we do not assume that *V* is spanned by the roots, i.e., that
`W.rank = W.semisimpleRank`

). This reflection representation and its
character contain some further useful information about~*W*.

Let *SV* be the symmetric algebra of *V*. The invariants of *W* in *SV*
are called the **polynomial invariants** of *W*. They are generated as a
polynomial ring by *dim V* homogeneous algebraically independent
polynomials *f_1,ldots,f_{dim V}*. The polynomials *f_i* are not
uniquely determined but their degrees are. The *f_i* are called the
**basic invariants** of *W*, and their degrees the **reflection degrees** of
*W*. Let *I* be the ideal generated by the homogeneous invariants of
positive degree in *SV*. Then *SV/I* is isomorphic to the regular
representation of *W* as a *W*-module. It is thus a graded (by the
degree of elements of *SV*) version of the regular representation of *W*.
The polynomial which gives the graded multiplicity of a character *chi*
of *W* in the graded module *SV/I* is called the **fake degree** of
*chi*. (See ReflectionCharValue, ReflectionDegrees and
FakeDegree.)

Using these constructions and the generic degrees of the corresponding
one-parameter generic Iwahori--Hecke algebra, one can associate four
integers *a,A,b,B* with each irreducible character of *W* (see the
functions LowestPowerGenericDegrees, HighestPowerGenericDegrees,
LowestPowerFakeDegrees, HighestPowerFakeDegrees, and
cite[Ch.11]Car85 for more details). These will also be used in the
operations of truncated inductions in chapter Reflection subgroups.

Iwahori-Hecke algebras associated with finite Coxeter groups also have character tables, see Chapter Iwahori-Hecke algebras.

We now describe, for each type of irreducible finite Coxeter groups, our conventions about labeling the classes and characters. Assume that the Root systems and finite Coxeter groups.

smallskip
noindent em Type *A_n* (*n geq 0*). In this case we have
*W cong {mathfrak S}_{n+1}*. The classes and characters are labeled by
partitions of *n+1*. The partition corresponding to a class describes the
cycle type for the elements in that class. The partition corresponding to
a character describes the type of the Young subgroup such that the
trivial character induced from this subgroup contains that character with
multiplicity~*1* and every other character occuring in this induced
character has a higher *a*-value. Thus, the sign character corresponds to
the partition *(1^{n+1})* and the trivial character to the partition
*(n+1)*. The character of the reflection representation of *W* is
labeled by *(n,1)*.

medskip
noindent em Type *B_n* (*n geq 2*). In this case *W=W(B_n)* is
isomorphic to the wreath product of the cyclic group of order~*2* with
the symmetric group *{mathfrak S}_n*. Hence the classes and characters
are parametrized by pairs of partitions such that the total sum of their
parts equals~*n*. The pair corresponding to a class describes the signed
cycle type for the elements in that class, as in Car72. We use the
convention that if *(lambda,mu)* is such a pair then *lambda*
corresponds to the positive and *mu* to the negative cycles. Thus,
*(1^n,-)* and *(-,1^n)* label the trivial class and the class containing
the longest element, respectively. The pair corresponding to an
irreducible character is determined via Clifford theory, as follows.

We have a semidirect product decomposition *W(B_n)=N.{mathfrak S}_n*
where *N* is the standard *n*-dimensional *{FF}_2^n*-vector space. For
*a,b geq 0* such that *n=a+b* let *eta_{a,b}* be the irreducible
character of *N* which takes value~*1* on the first~*a* standard basis
vectors and value~*-1* on the next *b* standard basis vectors
of~*N*. Then the inertia subgroup of *eta_{a,b}* has the form
*T_{a,b}:=N.({mathfrak S}_a times {mathfrak S}_b)* and we can extend
*eta_{a,b}* trivially to an irreducible character *tilde{eta}_{a,b}*
of *T_{a,b}*. Let *alpha* and *beta* be partitions of *a* and *b*,
respectively. We take the tensor product of the corresponding irreducible
characters of *{mathfrak S}_a* and *{mathfrak S}_b* and regard this as
an irreducible character of *T_{a,b}*. Multiplying this character with
*tilde{eta}_{a,b}* and inducing to *W(B_n)* yields an irreducible
character *chi= chi_{(alpha,beta)}* of *W(B_n)*. This defines the
correspondence between irreducible characters and pairs of partitions as
above.

For example, the pair *((n),-)* labels the trivial character and
*(-,(1^n))* labels the sign character. The character of the natural
reflection representation is labeled by *((n-1),(1))*.

smallskip
noindent em Type *D_n* (*n geq 4*). In this case *W=W(D_n)* can be
embedded as a subgroup of index~*2* into the Coxeter group *W(B_n)*. The
intersection of a class of *W(B_n)* with *W(D_n)* is either empty or a
single class in *W(D_n)* or splits up into two classes in *W(D_n)*. This
also leads to a parametrization of the classes of *W(D_n)* by pairs of
partitions *(lambda,mu)* as before but where the number of parts of
*mu* is even and where there are two classes of this type if *mu* is
empty and all parts of *lambda* are even. In the latter case we denote
the two classes in *W(D_n)* by *(lambda,+)* and *(lambda,-)*, where we
use the convention that the class labeled by *(lambda,+)* contains a
representative which can be written as a word in *{s_1,s_3,ldots,s_n}*
and *(lambda,-)* contains a representative which can be written as a
word in *{s_2,s_3, ldots,s_n}*.

By Clifford theory the restriction of an irreducible character of
*W(B_n)* to *W(D_n)* is either irreducible or splits up into two
irreducible components. Let *(alpha,beta)* be a pair of partitions
with total sum of parts equal to *n*. If *alpha neq beta* then the
restrictions of the irreducible characters of *W(B_n)* labeled by
*(alpha,beta)* and *(beta, alpha)* are irreducible and equal. If
*alpha=beta* then the restriction of the character labeled by
*(alpha,alpha)* splits into two irreducible components which we denote
by *(alpha,+)* and *(alpha,-)*. Note that this can only happen if *n*
is even. In order to fix the notation we use a result of Ste89
which describes the value of the difference of these two characters on a
class of the form *(lambda,+)* in terms of the character values of the
symmetric group *{mathfrak S}_{n/2}*. Recall that it is implicit in the
notation *(lambda,+)* that all parts of *lambda* are even. Let
*lambda^prime* be the partition of *n/2* obtained by dividing each part
by~*2*. Then the value of [chi_(alpha,-)-chi_(alpha,+)] on an
element in the class *(lambda,+)* is given by *2^{k(lambda)}* times the
value of the irreducible character of *{mathfrak S}_{n/2}* labeled by
*alpha* on the class of cycle type *lambda^prime*. (Here, *k(lambda)*
denotes the number of non-zero parts of *lambda*.)

The labels for the trivial, the sign and the natural reflection character
are the same as for *W(B_n)*, since these characters are restrictions of
the corresponding characters of *W(B_n)*.

smallskip
em Types *G_2* and *F_4*. The matrices of character values and the
orderings and labelings of the irreducible characters are exactly the
same as in cite[p.412/413]Car85. Note, however, that in CHEVIE we
have reversed the labeling of the Dynkin diagrams to be in accordance
with the conventions in cite[(4.8) and (4.10)]Lus85.

The classes are labeled by Carter's admissible diagrams Car72. A
character is labeled by a pair *(n,b)* where *n* denotes the degree and
*b* the corresponding *b*-invariant. If there are several characters with
the same pair *(n,b)* we attach a prime to them, as in Car85.

For type *F_4* the result of `ChevieCharInfo`

contains an additional
component `kondo`

which contains the labels originally given by Kondo
(and which are also used in cite[(4.10)]Lus85). The reflection
character is labeled by *(4,1)* or *4_2* (Kondo).

smallskip em Types *E_6,E_7,E_8*. The character tables are
re-constructed from the compound tables in the Cambridge ATLAS
CCN85, p.26, p.46 and p.85, respectively (or, they can be
recomputed with **GAP** by the general Dixon-Schneider algorithm). The
classes are labeled by Carter's admissible diagrams Car72. A
character is labeled by the pair *(n,b)* where *n* denotes the degree and
*b* is the corresponding *b*-invariant. For these types, this gives a
unique labeling of the characters. The result of `ChevieCharInfo`

contains an additional component `frame`

which contains the labels
originally given by Frame (and which are used in Lus85, (4.11),
(4.12), and (4.13)). For type *E_6*, *E_7*, *E_8*, respectively, the
reflection character is the one with label *(6,1)*, *(7,1)*, *(8,1)* or
*6_p*, *7_a^prime*, *8_z* (Frame).

smallskip
em Non-crystallographic types *I_2(m)*, *H_3*, *H_4*. In these cases
we do not have canonical labelings for the classes.

Each character for type *H_3* is uniquely determined by the pair *(n,b)*
where *n* is the degree and *b* the corresponding *b*-invariant. For type
*H_4* there are just two characters (those of degree~*30*) for which the
corresponding pairs are the same. These two characters are nevertheless
distinguished by their fake degrees: the first of these (in the
CHEVIE-table) has fake degree *q^{10}+q^{12}+* higher terms, while the
second has fake degree *q^{12}+q^{14}+* higher terms. The characters in
the CHEVIE-table for type *H_4* are ordered in the same way as in
AL82.

Finally, the characters of degree~*2* for type *I_2(m)* are ordered as
follows. Let *varepsilon* be a primitive *m*-th root of unity. Then
matrix representations affording the characters of degree~*2* are given
by:
[ varphi_j colon
s_1s_2 mapsto left( beginarraycc
varepsilon^j & 0

0 & varepsilon^-j endarray right),
quad s_1 mapsto left( beginarraycc
0 & 1

1 & 0 endarray right),]
where *1 leq j leq (m-1)/2* for *m* odd, and *1 leq j leq (m-2)/2*
for *m* even. The natural reflection representation determined by the root
system is *rho=varphi_1*.

In **GAP** we take *varepsilon* as `E( `

. Then the characters in the
CHEVIE-table are ordered as `m` )*varphi_1,varphi_2,ldots*.

- CharTable for Coxeter groups
- ReflectionCharValue
- ReflectionDegrees
- FakeDegrees
- FakeDegree
- LowestPowerFakeDegrees
- HighestPowerFakeDegrees
- LowestPowerGenericDegrees
- HighestPowerGenericDegrees
- ChevieCharInfo
- PositionId and PositionSgn

`CharTable( `

`W` )

returns the character table of the Coxeter group `W`. This is a
character table record as defined in **GAP**. It is assigned to the record
component `charTable`

of `W`. The function `CharTable`

checks if this
component is already bound. The (variable) record components
`classtext`

, `classnames`

and `irredinfo`

contain the following
information.

`classtext`

:

a list of reduced expressions for minimal length representatives in the conjugacy classes of`W`

`classnames`

:

a list of Carter's admissible diagrams (for exceptional, irreducible types) or partitions resp. pairs of partitions (for classical, irreducible types). If the Coxeter group is not irreducible tuples of such labels are given.

`irredinfo`

:

a list of records with a component`charname`

which contains a string with a label for an irreducible character. For an irreducible Coxeter group this label can either be a partition or a pair of partitions, or it is a pair*(n,e)*where*n*is the degree of the character and*e*is the smallest symmetric power of the character of the natural reflection representation which contains the given character as a component. The optional second component,`charparam`

, contains this label as a list of numbers (if it is possible to give it in this way). The labels for the group is a list of labels corresponding to the irreducible components (as given by`CartanType`

).

gap> W := CoxeterGroup( "G", 2);; gap> ct := CharTable( W ); CharTable( "W( G2 )" ) gap> ct.classtext; [ [ ], [ 2 ], [ 1 ], [ 1, 2 ], [ 1, 2, 1, 2 ], [ 1, 2, 1, 2, 1, 2 ] ] gap> ct.classnames; [ " ", "~A_1", "A_1", "G_2", "A_2", "A_1 + ~A_1" ] gap> ct.irredinfo; [ rec( charparam := [ [ 1, 0 ] ], charname := "phi_{1,0}" ), rec( charparam := [ [ 1, 6 ] ], charname := "phi_{1,6}" ), rec( charparam := [ [ 1, 3, "'" ] ], charname := "phi_{1,3}'" ), rec( charparam := [ [ 1, 3, "''" ] ], charname := "phi_{1,3}''" ), rec( charparam := [ [ 2, 1 ] ], charname := "phi_{2,1}" ), rec( charparam := [ [ 2, 2 ] ], charname := "phi_{2,2}" ) ]

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

`ReflectionCharValue( `

`W`, `w` )

Let `V` be the vector space on which the Coxeter group `W` acts, and let
`w` be the linear automorphism of *V* induced by a permutation of the
roots (acting trivially on the orthogonal of the roots if
`W.rank`

). `W.semisimpleRank``ReflectionCharValue`

returns the trace of
`w` on `V`.

gap> W := CoxeterGroup( "A", 3 ); CoxeterGroup("A", 3) gap> List( Elements( W ), x -> ReflectionCharValue( W, x ) ); [ 3, 1, -1, 0, -1, -1, 0, 1, 0, -1, 1, 0, 1, -1, 0, 1, -1, -1, 0, -1, 1, 0, -1, 0 ]

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

`ReflectionDegrees( `

`W` )

returns a list holding the degrees of *W* as a reflection group on the
vector space *V* on which it acts. These are the degrees
*d_1,ldots,d_{dim V}* of the basic invariants of *W* in *SV*, written
in increasing order. They reflect various properties of *W*; in
particular, their product is the size of *W*.

gap> W := CoxeterGroup( "H", 4 ); CoxeterGroup("H", 4) gap> ReflectionDegrees( W ); [ 2, 12, 20, 30 ] gap> Size( W ); 14400

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

`FakeDegrees( `

`W`, `q` )

returns a list holding the fake degrees of *W* as a reflection group on
the vector space *V* on which it acts, evaluated at `q`. These are the
graded multiplicities of the irreducible characters of *W* in the
quotient *SV/I* where *SV* is the symmetric algebra of *V* and *I* is the
ideal generated by the homogeneous invariants of positive degree in *SV*.
The ordering of the result corresponds to the ordering of the characters
in `CharTable(W)`

.

gap> q := X( Rationals );; q.name := "q";; gap> FakeDegrees( CoxeterGroup( "A", 2 ), q ); [ q^3, q^2 + q, q^0 ]

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

`FakeDegree( `

`W`, `phi`, `q` )

returns the fake degree of the character labelled by `phi` of the Coxeter
group *W* as a reflection group on the vector space *V* on which it acts,
evaluated at `q`. The label `phi` should be the parameter given as a
Operations and functions for Coxeter groups).

gap> q := X( Rationals );; q.name := "q";; gap> FakeDegree( CoxeterGroup( "A", 2 ), [ [ 2, 1 ] ], q ); q^2 + q

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

`LowestPowerFakeDegrees( `

`W` )

return a list holding the *b*-function for all irreducible characters of
*W*, that is, for each character *chi*, the valuation of the fake degree
of *chi*. The ordering of the result corresponds to the ordering of the
characters in `CharTable(W)`

.

gap> LowestPowerFakeDegrees( CoxeterGroup( "D", 4 ) ); [ 6, 6, 7, 12, 4, 3, 6, 2, 2, 4, 1, 2, 0 ]

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

`HighestPowerFakeDegrees( `

`W` )

returns a list holding the *B*-function for all irreducible characters of
*W*, that is, for each character *chi*, the degree of the fake degree of
*chi*. The ordering of the result corresponds to the ordering of the
characters in `CharTable(W)`

.

gap> HighestPowerFakeDegrees( CoxeterGroup( "D", 4 ) ); [ 10, 10, 11, 12, 8, 9, 10, 6, 6, 8, 5, 6, 0 ]

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

`LowestPowerGenericDegrees( `

`W` )

returns a list holding the *a*-function for all irreducible characters of
the Coxeter group `W`, that is, for each character *chi*, the valuation
of the generic degree of *chi* (in the one-parameter Iwahori-Hecke
algebra `Hecke(W,X(Rationals))`

corresponding to `W`). The ordering of
the result corresponds to the ordering of the characters in
`CharTable(W)`

.

gap> LowestPowerGenericDegrees( CoxeterGroup( "D", 4 ) ); [ 6, 6, 7, 12, 3, 3, 6, 2, 2, 3, 1, 2, 0 ]

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

`HighestPowerGenericDegrees( `

`W` )

returns a list holding the *A*-function for all irreducible characters of
the Coxeter group `W`, that is, for each character *chi*, the degree of
the generic degree of *chi* (in the one-parameter Iwahori-Hecke algebra
`Hecke(W,X(Rationals))`

corresponding to `W`). The ordering of the
result corresponds to the ordering of the characters in `CharTable(W)`

.

gap> HighestPowerGenericDegrees( CoxeterGroup( "D", 4 ) ); [ 10, 10, 11, 12, 9, 9, 10, 6, 6, 9, 5, 6, 0 ]

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

`ChevieCharInfo( `

`W` )

returns information about the irreducible characters of the finite
Coxeter group `W`. The result is a record with the components:
`charparams`

contains the result of `CharParams(`

, `W`)`charnames`

contains the corresponding names returned by `CharName`

, and `a`

, `A`

,
`b`

, `B`

, contain the results of `LowestPowerGenericDegrees(`

,
`W`)`HighestPowerGenericDegrees(`

, `W`)`LowestPowerFakeDegrees(`

,
`W`)`HighestPowerFakeDegrees(`

, respectively. Moreover, the components
`W`)`positionId`

and `positionSgn`

contain the position of the trivial and
the sign character, respectively, in the character table of `W`. If `W`
is irreducible, there is an additional component `positionRefl`

which
contains the position of the character of the reflection representation.

gap> ChevieCharInfo( CoxeterGroup( "G", 2 ) ); rec( charparams := [ [ [ 1, 0 ] ], [ [ 1, 6 ] ], [ [ 1, 3, "'" ] ], [ [ 1, 3, "''" ] ], [ [ 2, 1 ] ], [ [ 2, 2 ] ] ], charnames := [ "phi_{1,0}", "phi_{1,6}", "phi_{1,3}'", "phi_{1,3}''", "phi_{2,1}", "phi_{2,2}" ], a := [ 0, 6, 1, 1, 1, 1 ], A := [ 0, 6, 5, 5, 5, 5 ], b := [ 0, 6, 3, 3, 1, 2 ], B := [ 0, 6, 3, 3, 5, 4 ], positionId := 1, positionSgn := 2, positionRefl := 5 )

If `W` is irreducible of type *F_4* or of type *E_n* (*n=6,7,8*) then
there is an additional component `kondo`

or `frame`

, respectively, which
gives the labeling of the characters as determined by Kondo and Frame.

gap> W := CoxeterGroup( "E", 6 );; gap> ChevieCharInfo( W ).frame; [ "1_p", "1_p'", "10_s", "6_p", "6_p'", "20_s", "15_p", "15_p'", "15_q", "15_q'", "20_p", "20_p'", "24_p", "24_p'", "30_p", "30_p'", "60_s", "80_s", "90_s", "60_p", "60_p'", "64_p", "64_p'", "81_p", "81_p'" ]

See also ChevieClassInfo.

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

`PositionId( `

`W` )

`PositionSgn( `

`W` )

return the position of the trivial and the sign character, respectively,
in the character table of the group `W`.

gap> W := CoxeterGroup( "D", 4 );; gap> PositionId( W ); 13 gap> PositionSgn( W ); 4

For `PositionId`

, one could also give an arbitrary finite group or its
character table as argument.

See also ChevieClassInfo.

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

Index

GAP 3.4.4

April 1997