The `CharTable`

of a finite complex reflection group `W` is computed in
**CHEVIE** using the decomposition of `W` in irreducible groups (see
ReflectionType). For each irreducible group the character table is
either computed using recursive formulas for the infinite series, or
read into the system from a library file for the exceptional types.
Thus, character tables can be obtained quickly even for very large
groups (e.g., *E _{8}*). Similar remarks apply for conjugacy classes.

The conjugacy classes and irreducible characters of irreducible finite
complex reflection groups have canonical labelings by certain combinatorial
objects; these labelings are used in the tables of **CHEVIE**. For the
classes, these are partitions or partition tuples for the infinite series,
or, for exceptional Coxeter groups, Carter's admissible diagrams
Car72 (for other primitive complex reflection groups we just use
words in the generators to specify the classes). For the characters, these
are again partitions or partition tuples for the infinite series, and for
the others they are pairs of two integers *(n,e)* where *n* is the degree
of the character and *e* is the smallest symmetric power of the reflection
representation containing the given character as a constituent. This
information is obtained by using the functions `ChevieClassInfo`

and
`ChevieCharInfo`

(and some of it is also available more directly via the
functions `CharParams`

, `CharName`

, `HighestPowerFakeDegrees`

). When you
display the character table in **GAP**, the canonical labelings for classes
and characters are those displayed.

A typical example is `CoxeterGroup("A",`

, the symmetric group
`n`)* S_{n+1}* where classes and characters are parameterized by partitions
of

gap> W := CoxeterGroup( "A", 3 );; gap> Display( CharTable( 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

The `charTable`

record (computed the first time the function `CharTable`

is called) is a usual character table record as defined in **GAP**,
but with some additional components. The components `classtext`

,
`classnames`

contain information as described for `ChevieClassInfo`

(see
ChevieClassInfo). There is also a field `irredinfo`

, which is a
list of records for each irreducible character which have components
`charname`

and `charparam`

as described for `ChevieCharInfo`

(see
ChevieCharInfo).

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

Recall that our groups acts a reflection group on the vector space *V*, so
have fake degrees (see FakeDegree). The valuation and degree of these
give two integers *b,B* for each irreducible character of *W* (see
LowestPowerFakeDegrees and HighestPowerFakeDegrees). For finite Coxeter
groups, the valuation and degree of the generic degrees of the
one-parameter generic Hecke algebra give two more integers *a,A* (see the
functions LowestPowerGenericDegrees, HighestPowerGenericDegrees, and
Car85, Ch.11 for more details). These will also be used in the
operations of truncated inductions explained in the chapter Reflection
subgroups.

Iwahori-Hecke algebras and cyclotomic Hecke algebras also have character tables, see the corresponding chapters.

We now describe for each type our conventions for labeling the classes and characters.

** Type A_{n} (n ≥ 0)**. In this case we have

`.classtext`

is
the concatenation of the words corresponding to each part, and to a part

** Type B_{n} (n ≥ 2)**. In this case

We have a semidirect product decomposition *W(B _{n})=N.S_{n}* where

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

** Type D_{n} (n ≥ 4)**. In this case

By Clifford theory the restriction of an irreducible character of *W(B _{n})*
to

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

** The groups G(d,1,n)**.
They are isomorphic to the wreath product of the cyclic group of
order

The *d*-tuple corresponding to an irreducible character is determined
via Clifford theory in a similar way than for the *B _{n}* case. The
identity character has the first partition with one part equal

** The groups G(de,e,n)**.
They are normal subgroups of index

According to Hu85, a class *C* of *G(de,1,n)* parameterized by a
*de*-partition *(S _{0},...,S_{de-1})* is in

`g^i w g^-i`

for ```
i in
[0..d-1]
```

are representatives of the classes of
The characters are described by Clifford theory. We make *g* act on labels
for characters of *G(de,1,n)* . The action of *g* permutes circularly by
*d* the partitions in the *de*-tuple. A character has same restriction to
*G(de,e,n)* as its transform by *g*. The number of irreducible components
of its restriction is equal to the order *k* of its stabilizer under powers
of *g*. We encode a character of *G(de,e,n)* by first, choosing the
smallest for lexicographical order label of a character whose restriction
contains it; then this label is periodic with a motive repeated *k* times;
we represent the character by one of these motives, to which we append
*E(k) ^{i}* for

`i in [0..k-1]`

to describe which component of the restriction
we choose.

** 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 Car85, p.412/413: in type

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 Lus85, (4.10)).

** Types E_{6},E_{7},E_{8}**. The character tables are obtained by
specialization of those of the Hecke algebra. The classes are labeled by
Carter's admissible diagrams Car72. A character is labeled by the
pair

`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)).

** 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

Finally, the characters of degree *2* for type *I _{2}(m)* are ordered as
follows. The matrix representations affording the characters of degree

ρ_{j} : s_{1}s_{2} →
( |
| ),
s_{1}→( |
| ), |

** Primitive complex reflection groups G_{4} to G_{34}**.
The groups

• For *G _{27}*:\
The fake degree of

• For *G _{29}*:\
The character

• For *G _{31}*:\
The characters

• For *G _{33}*:\
The terms of maximal degree of the fakedegree of

• For *G _{34}*:\
The character

For the groups *G _{5}* and

• For *G _{5}*:\
We let

`W:=ComplexReflectionGroup(5)`

, so the generators in `W.1`

and `W.2`

.
The character *φ _{1,4}'* (resp.

`E(3)`

, `-E(3)`

) on `W.1`

.
The character `W.1`

. The character

• For *G _{7}*:\
We let

`W:=ComplexReflectionGroup(7)`

, so the generators in `W.1`

, `W.2`

and `W.3`

.
The characters *φ _{1,4}'* and

`W.2`

. The character `E(3)`

on `W.2`

. The character
`-E(3)`

on `W.2`

and
`W.2`

. The characters
Finally, for the remaining groups *G _{6}, G_{8}* to

• If the two characters have different fake degrees, label
*φ _{n,b}'* the one whose fake degree is minimal for the
lexicographic order of polynomials (starting with the highest term).

• For the not yet labeled pairs, if only one of the two characters has
the property that in its Galois orbit at least one character is
distinguished by its *(n,b)*-invariant, label it *φ _{n,b}'*.

• For the not yet labeled pairs, if the minimum of the *(n,b)*-value
(for the lexicographic order *(n,b)*) in the Galois orbits of the two
character is different, label *φ _{n,b}'* the character with the
minimal minimum.

•
We define now a new invariant for characters: consider all the pairs of
irreducible characters *χ* and *ψ* uniquely determined by their
*(n,b)*-invariant such that *φ* occurs with non-zero multiplicity *m* in
*χ⊗ψ*. We define *t(φ)* to be the minimal (for lexicographic
order) possible list *(n(χ),b(χ),n(ψ),b(ψ),m)*.

For the not yet labeled pairs, if the t-invariants are different,
label *φ _{n,b}'* the character with the minimal

After applying the last rule all the pairs will be labelled for the
considered groups. The labelling obtained is compatible for *G _{25}*,

We should emphasize that for all groups with a few exceptions, the
parameters for characters do not depend on any non-canonical choice. The
exceptions are *G(de,e,n)* with *e>1*, and *G _{5}*,

** Labels for the classes.** For the exceptional complex
reflection groups, the labels for the classes represent the decomposition
of a representative of the class as a product of generators, with the
additional conventions that `z`

represents the generator of the center and
for well-generated groups `c`

represents a Coxeter element (a product of
the generators which is a regular element for the highest reflection
degree).

`CharParams`

:

Returns the list of parameters for irreducible characters of`W`as partitions for type`A`

, double partitions for type`B`

, etc...`CharName`

also has a special version which knows how to display nicely such labels.

- ChevieClassInfo
- WordsClassRepresentatives
- ChevieCharInfo
- FakeDegrees
- FakeDegree
- LowestPowerFakeDegrees
- HighestPowerFakeDegrees
- Representations
- LowestPowerGenericDegrees
- HighestPowerGenericDegrees
- PositionDet
- DetPerm

`ChevieClassInfo( `

`W` )

returns information about the conjugacy classes of the finite reflection
group `W`. The result is a record with three components:\

`classtext`

:

contains words in the generators describing representatives of each conjugacy class; this is the same as`WordsClassRepresentatives(`

and for finite Coxeter groups the representatives given are of minimal length (the representatives taken are explained in GM97).`W`)

`classparams`

:

The elements of this list are tuples which have one component for each irreducible component of`W`. These components for the infinite series, contain partitions or partition tuples describing the class (see the introduction). For the exceptional Coxeter groups they contain Carter's admissible diagrams, see Car72. For exceptional complex reflection groups they contain in general the same information as in classtext.

`classnames`

:

Contains strings describing the conjugacy classes, made out of the information in`classparams`

.

gap> ChevieClassInfo(CoxeterGroup( "D", 4 )); rec( classtext := [ [ ], [ 1, 2 ], [ 1, 2, 3, 1, 2, 3, 4, 3, 1, 2, 3, 4 ], [ 1 ], [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 4 ], [ 2, 4 ], [ 1, 3, 1, 2, 3, 4 ], [ 1, 3 ], [ 1, 2, 3, 4 ], [ 1, 4, 3 ], [ 2, 4, 3 ] ], classparams := [ [ [ [ 1, 1, 1, 1 ], [ ] ] ], [ [ [ 1, 1 ], [ 1, 1 ] ] ], [ [ [ ], [ 1, 1, 1, 1 ] ] ], [ [ [ 2, 1, 1 ], [ ] ] ], [ [ [ 1 ], [ 2, 1 ] ] ], [ [ [ 2 ], [ 1, 1 ] ] ], [ [ [ 2, 2 ], '+' ] ], [ [ [ 2, 2 ], '-' ] ], [ [ [ ], [ 2, 2 ] ] ], [ [ [ 3, 1 ], [ ] ] ], [ [ [ ], [ 3, 1 ] ] ], [ [ [ 4 ], '+' ] ], [ [ [ 4 ], '-' ] ] ], classnames := [ "1111.", "11.11", ".1111", "211.", "1.21", "2.11", "22.+", "22.-", ".22", "31.", ".31", "4.+", "4.-" ]) gap> ChevieClassInfo(ComplexReflectionGroup(3,1,2)); rec( classparams := [ [ [ [ 1, 1 ], [ ], [ ] ] ], [ [ [ 1 ], [ 1 ], [ ] ] ], [ [ [ 1 ], [ ], [ 1 ] ] ], [ [ [ ], [ 1, 1 ], [ ] ] ], [ [ [ ], [ 1 ], [ 1 ] ] ], [ [ [ ], [ ], [ 1, 1 ] ] ], [ [ [ 2 ], [ ], [ ] ] ], [ [ [ ], [ 2 ], [ ] ] ], [ [ [ ], [ ], [ 2 ] ] ] ], classtext := [ [ ], [ 1 ], [ 1, 1 ], [ 1, 2, 1, 2 ], [ 1, 1, 2, 1, 2 ], [ 1, 1, 2, 1, 2, 2, 1, 2 ], [ 2 ], [ 1, 2 ], [ 1, 1, 2 ] ], classnames := [ "11..", "1.1.", "1..1", ".11.", ".1.1", "..11", "2..", ".2.", "..2" ])

See also the introduction of this section.

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

`WordsClassRepresentatives( `

`W` )

returns a list of representatives of the conjugacy classes of the complex
reflection group `W`. Each element in this list is given as a positive word
in the standard generators, which is represented as a list of integers
where the generator *s _{i}* is represented by the integer

`List(ConjugacyClasses(W),x->CoxeterWord(W,Representative(x)))`

, and each
representative given by

gap> WordsClassRepresentatives( CoxeterGroup( "F", 4 ) ); [ [ ], [ 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 ], [ 2, 3, 2, 3 ], [ 2, 1 ], [ 1, 2, 3, 4, 2, 3, 2, 3, 4, 3 ], [ 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 ], [ 4, 3 ], [ 1, 2, 1, 3, 2, 3, 1, 2, 3, 4 ], [ 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 ], [ 1, 2, 3, 4, 1, 2, 3, 4 ], [ 1, 2, 3, 4 ], [ 1 ], [ 2, 3, 2, 3, 4, 3, 2, 3, 4 ], [ 1, 4, 3 ], [ 4, 3, 2 ], [ 2, 3, 2, 1, 3 ], [ 3 ], [ 1, 2, 1, 3, 2, 1, 3, 2, 3 ], [ 2, 1, 4 ], [ 3, 2, 1 ], [ 2, 4, 3, 2, 3 ], [ 1, 3 ], [ 3, 2 ], [ 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 2, 3 ], [ 1, 2, 3, 4, 2, 3 ] ]

See also ChevieClassInfo.

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

`ChevieCharInfo( `

`W` )

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

`charparams`

:

contains parameters for the irreducible characters as described in the introduction or returned by`CharParams(`

. The parameters are tuples with one component for each irreducible irreducible component of`W`)`W`(as given by`ReflectionType`

). For an irreducible component which is an imprimitive reflection group the component of the`charparam`

is a tuple of partitions, and for a primitive irreducible group 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 reflection representation which contains the given character as a component.

`charnames`

:

strings describing the irreducible characters, computed from the`charparams`

.

`positionId`

:

the position of the trivial character in the character table of`W`(which is also returned by the function`PositionId`

).

`extRefl`

:

Only present if`W`is irreducible, in which case the reflection representation of`W`and all its exterior powers are irreducible. It then contains the position of the exterior powers of the reflection representation in the character table.

`a`

:

contains the result of`LowestPowerFakeDegrees(`

.`W`)

`A`

:

contains the result of`HighestPowerFakeDegrees(`

.`W`)

`b`

:

Only filled for Spetsial groups. Contains the result of`LowestPowerGenericDegrees(`

.`W`)

`B`

:

Only filled for Spetsial groups. Contains the result of`HighestPowerGenericDegrees(`

.`W`)

`positionSgn`

:

Contains the position of the determinant character in the character table of`W`(which is also returned by the function`PositionDet`

). For Coxeter groups this is the sign character.

gap> ChevieCharInfo(ComplexReflectionGroup(4)); rec( charparams := [ [ [ 1, 0 ] ], [ [ 1, 4 ] ], [ [ 1, 8 ] ], [ [ 2, 5 ] ], [ [ 2, 3 ] ], [ [ 2, 1 ] ], [ [ 3, 2 ] ] ], extRefl := [1, 6, 2], a := [ 0, 4, 4, 4, 1, 1, 2 ], A := [ 0, 8, 8, 8, 5, 5, 6 ], b := [ 0, 4, 8, 5, 3, 1, 2 ], charnames := [ "phi{1,0}", "phi{1,4}", "phi{1,8}", "phi{2,5}", "phi{2,3}", "phi{2,1}", "phi{3,2}" ], positionId := 1, positionDet := 2, B := [ 0, 4, 8, 7, 5, 3, 6 ] )

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

If `W` is irreducible of type *F _{4}* or of type

`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'" ]

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

`FakeDegrees( `

`W`, `q` )

returns a list holding the fake degrees of the reflection group *W*
on the vector space *V*, 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 of parameter `phi` (see
CharParams) of the reflection group *W*, evaluated at `q` (see
FakeDegrees for a definition of the fake degrees).

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 *χ*, the valuation of the fake
degree of *χ*. The ordering of the result corresponds to the ordering
of the characters in `CharTable(W)`

. The advantage of this function
compared to calling `FakeDegrees`

is that one does not have to provide
an indeterminate, and that it may be much faster to compute than the
fake degrees.

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 *χ*, the degree of the fake
degree of *χ*. The ordering of the result corresponds to the ordering
of the characters in `CharTable(W)`

. The advantage of this function
compared to calling `FakeDegrees`

is that one does not have to provide
an indeterminate, and that it may be much faster to compute than the
fake degrees.

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).

`Representations( `

`W`[, `l`])

returns a list holding, for each irreducible character of the complex
reflection group `W`, a list of matrices images of the generating
reflections of `W` in a model of the corresponding representation. This
function is based on the classification, and is not yet fully implemented
for *G _{34}*; still missing are 3 representations of dim. 70, 4 of dim.
105, 4 of dim. 315, 6 of dim. 420 and those of dim. 90, 120, 140, 189, 280,
384 or greater than 420.

If there is a second argument, it can be a list of indices (or a single integer) and only the representations with these indices (or that index) in the list of all representations are returned.

gap> Representations(CoxeterGroup("B",2)); [ [ [ [ 1 ] ], [ [ -1 ] ] ], [ [ [ 1, 0 ], [ -1, -1 ] ], [ [ 1, 2 ], [ 0, -1 ] ] ], [ [ [ -1 ] ], [ [ -1 ] ] ], [ [ [ 1 ] ], [ [ 1 ] ] ], [ [ [ -1 ] ], [ [ 1 ] ] ] ] gap> Representation(ComplexReflectionGroup(4),7); [ [ [ E(3)^2, 0, 0 ], [ 2*E(3)^2, E(3), 0 ], [ E(3), 1, 1 ] ], [ [ 1, -1, E(3) ], [ 0, E(3), -2*E(3)^2 ], [ 0, 0, E(3)^2 ] ] ]

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 or Spetsial reflection group `W`, that is, for each
character *χ*, the valuation of the generic degree of *χ* (in the
one-parameter Hecke algebra `Hecke(W,X(Cyclotomics))`

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 or Spetsial reflection group `W`, that is, for each
character *χ*, the degree of the generic degree of *χ* (in the
one-parameter Hecke algebra `Hecke(W,X(Cyclotomics))`

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).

`PositionDet( `

`W` )

return the position of the determinant character in the character table of
the group `W` (for Coxeter groups this is the sign character).

gap> W := CoxeterGroup( "D", 4 );; gap> PositionDet( W ); 4

See also `ChevieCharInfo`

(ChevieCharInfo).

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

`DetPerm( `

`W` )

return the permutation of the characters of the reflection group `W` which
is effected when tensoring by the determinant character (for Coxeter groups
this is the sign character).

gap> W := CoxeterGroup( "D", 4 );; gap> DetPerm( W ); [ 8, 9, 11, 13, 5, 6, 12, 1, 2, 10, 3, 7, 4 ]

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

Index

GAP 3.4.4

April 1997