Let W be a finite reflection group on the vector space V over a subfield of the complex numbers. An efficient representation (for computational purposes) that we use in CHEVIE for such a group, is a permutation representation on a set of root vectors for reflections of W (that is, a subset R of V invariant by W and such that all reflections in W are reflections with respect to some root in R). This generalizes the usual construction for Coxeter groups (the special case of real reflection groups) where to each reflection of W is associated two roots (a positive and a negative one). For complex reflection groups the situation may be worse, in that more roots lie on the same line (we need at least as many as the order of the center of W, when W is irreducible so its center acts via scalars on V). There is not yet a general theory on how to construct a nice set of roots for a non-real reflection group; the roots given in GAP where obtained case-by-case in an ad hoc way; however, the roots chosen for the generators of W are such that these generators satisfy braid relations which (conjecturally in the case of G34) present the braid group associated to W.
The field of definition of W is the field generated by the traces of the elements of W acting on V. It turns out that, as for rational reflection groups (Weyl groups), all representations of a complex reflection group W are defined over the field of definition of W (cf. Ben76 and D. Bessis thesis).
The finite irreducible complex reflection groups have been completely
classified by Shepard and Todd. They contain one infinite family
depending on 3 parameters, and 34 ``exceptional'' groups (which have
been given by Shephard and Todd a number which actually varies from
4 to 37, and covers also the exceptional Coxeter groups, e.g.,
CoxeterGroup("E",8)
is the group of Shephard-Todd number 37).
CHEVIE provides functions to build any finite reflection group,
described in terms of the classification, or by generating reflections
described in term of roots; the output is a permutation group of a root
system (see ComplexReflectionGroup
and PermRootGroup
). Of course, in
the context e.g. of Weyl groups, one wants to describe the particular
root system chosen in term of the traditional classification of
crystallographic root systems. This is done via calls to the function
CoxeterGroup
(see the chapter on finite Coxeter groups). There are
also other ways to construct a Coxeter group without a priori knowledge
of its classification.
The finite reflection groups are reflection groups, so in
addition to the fields for permutation groups they have the
fields .nbGeneratingReflections
, .OrdersGeneratingReflections
and
.reflections
. They also have the following additional fields:
roots
:W.roots{[1..W.semisimpleRank]}
should be linearly independent.
simpleCoroots
:.nbGeneratingReflections
roots.
semisimpleRank
:In this chapter we describe functions available for finite reflection groups represented as permutation groups on a set of roots. These functions make use of the classification whenever it is known, but work even if it is not known.
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 f1,...,fdim V. The polynomials fi are not uniquely determined but their degrees are. The fi 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 χ of W in the graded module SV/I is called the fake degree of χ.
They are permutation groups, so all functions for permutation groups
apply, although some are replaced by faster methods when available. A
typical example is the function Size
, which is obtained simply by the
product of the reflection degrees, when they are known. Appropriate
methods for String
and Print
are also defined. We mention also the
following functions described in the chapter about finite coxeter
groups:
ReflectionType(W)
:ST
, given either
with an integer n (for exceptional reflection groups Gn), or
a triple (p,q,r) of integers (for imprimitive reflection groups
G(p,q,r)). This function is called automatically prior to calling any
function depending on the classification, such as PrintDiagram
,
ReflectionName
, ChevieClassInfo
, BraidRelations
, CharName
,
CharParams
, Representations
, Invariants
.
ReflectionName(W)
:These functions require the package "chevie" (see RequirePackage).
PermRootGroup( roots [,eigenvalues])
PermRootGroup( roots, coroots)
roots is a list of roots, that is of vectors in some vector
space. PermRootGroup
returns the reflection group generated by the
reflections with respect to these roots (if this group is not finite,
the function will never return). The precise way the reflections are
constructed as matrices is specified by the second argument. In the
second form the i
-th reflection is computed as Reflection(roots[i],
coroots[i])
. In the first form eigenvalues represents non-trivial
eigenvalues of the reflections to construct, represented as a list of
fractions n/d
, where such a fraction represents the eigenvalue
E(d)^n
(the reason for using such a representation instead of
E(d)^n
is that in GAP it is trivial to compute E(d)^n
given
d/n, but the converse is hard). In this form the i
-th reflection is
computed as Reflection(roots[i], E(d)^n)
where eigenvalues[i]=n/d
.
If in the first form eigenvalues
are omitted, they are all assumed to
be 1/2
(which represents the number -1
, i.e. all reflections are
true reflections).
gap> W:=PermRootGroup(IdentityMat(3),CartanMat("A",3)); PermRootGroup([ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], [ [ 2, -1, 0 ], [ -1, 2, -1 ], [ 0, -1, 2 ] ]) gap> ReflectionDegrees(W); [ 2, 3, 4 ] gap> ReflectionType(W); [ rec( series := "A", rank := 3, operations := ReflTypeOps, indices := [ 1, 2, 3 ] ) ] gap> PrintDiagram(W); A3 1 - 2 - 3
In the above, the call to ReflectionType
makes CHEVIE identify the
classification of W
, after which functions like PrintDiagram
can
work. Below is another way to build a group of type A3.
gap> W:=PermRootGroup([[1,0,-1],[-1,1,0],[1,0,1]]); PermRootGroup([ [ 1, 0, -1 ], [ -1, 1, 0 ], [ 1, 0, 1 ] ], [ 1/2, 1/2, 1/2 ]) gap> ReflectionDegrees(W); [ 2, 3, 4 ]
This function requires the package "chevie" (see RequirePackage).
ComplexReflectionGroup( STnumber )
ComplexReflectionGroup( p, q, r )
The first form of ComplexReflectionGroup
returns the complex reflection
group which has Shephard-Todd number STnumber, see ST54. The
second form returns the imprimitive complex reflection group G(p,q,r).
gap> G := ComplexReflectionGroup( 4 ); ComplexReflectionGroup(4) gap> ReflectionDegrees( G ); [ 4, 6 ] gap> Size( G ); 24 gap> q := X( Cyclotomics );; q.name := "q";; gap> FakeDegrees( G, q ); [ q^0, q^4, q^8, q^7 + q^5, q^5 + q^3, q^3 + q, q^6 + q^4 + q^2 ] gap> ComplexReflectionGroup(2,1,6); CoxeterGroup("B",6)
This function requires the package "chevie" (see RequirePackage).
Reflections( W )
returns the list of reflections of W (as elements of W).
The i
-th entry in this list is the reflection along the
i
-th root in W.roots
. The generating reflections of W are
Reflections(W){[1..W.nbGeneratingReflections]}
.
gap> W := CoxeterGroup( "B", 2 );; gap> Reflections( W ); [ (1,5)(2,4)(6,8), (1,3)(2,6)(5,7), (2,8)(3,7)(4,6), (1,7)(3,5)(4,8) ]
This function requires the package "chevie" (see RequirePackage).
MatXPerm( W, w )
Let w be a permutation of the roots of the finite reflection group W
with reflection representation V. MatXPerm
returns the matrix of a
linear transformation of V which acts trivially on the orthogonal of
the coroots and has same effect as w on the simple roots. Only the
images of the simple roots by w is used. If w is an element of W
MatXPerm
thus returns the matrix of w acting on V. The function
makes sense more generally for an element of the normalizer of W in
the whole permutation group of the roots.
gap> W := CoxeterGroup( > [ [ 2, 0,-1, 0, 0, 0, 1 ], [ 0, 2, 0,-1, 0, 0, 0 ], > [-1, 0, 2,-1, 0, 0,-1 ], [ 0,-1,-1, 2,-1, 0, 0 ], > [ 0, 0, 0,-1, 2,-1, 0 ], [ 0, 0, 0, 0,-1, 2, 0 ] ], > [ [ 1, 0, 0, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 0, 0 ], > [ 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0 ], > [ 0, 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 0, 0, 1, 0 ] ] );; gap> w0 := LongestCoxeterElement( W );; gap> mx := MatXPerm( W, w0 ); [ [ 0, 0, 0, 0, 0, -1, 1 ], [ 0, -1, 0, 0, 0, 0, 2 ], [ 0, 0, 0, 0, -1, 0, 3 ], [ 0, 0, 0, -1, 0, 0, 4 ], [ 0, 0, -1, 0, 0, 0, 3 ], [ -1, 0, 0, 0, 0, 0, 1 ], [ 0, 0, 0, 0, 0, 0, 1 ] ]
This function requires the package "chevie" (see RequirePackage).
PermMatX( W, M )
Let M be a linear transformation of reflection representation of W
which preserves the set of roots, and thus normalizes W (remember
that matrices act on the right in GAP). PermMatX
returns the
corresponding permutation of the roots; it returns false
if M does
not normalize the set of roots.
We continue the example from MatXPerm
and obtain:
gap> PermMatX( W, mx ) = w0; true
This function requires the package "chevie" (see RequirePackage).
ReflectionEigenvalues( W [, c])
Let W be a reflection group on the vector space V.
ReflectionEigenvalues( W)
returns the list for each conjugacyclasses
of the eigenvalues of an element of that class acting on V. This is
returned as a list of fractions i/n
, where such a fraction represents
the eigenvalue E(n)^i
(the reason for returning such a representation
instead of E(n)^i
is that in GAP it is trivial to compute
E(n)^i
given i/n, but the converse is hard). If a second argument
c is given, returns only the list of eigenvalues of an element of the
cth conjugacy class.
gap> W:=CoxeterGroup("A",2); CoxeterGroup("A",2) gap> ReflectionEigenvalues(W,3); [ 1/3, 2/3 ]
This function requires the package "chevie" (see RequirePackage).
ReflectionLength( W, w )
This function returns the number of eigenvalues of w in the reflection representation which are not equal to 1. For a finite Coxeter group, this is equal to the minimum number of reflections of which w is a product. This also holds in general in a well-generated complex reflection group if w divides a Coxeter element for the reflection length.
gap> W:=CoxeterGroup("A",4); CoxeterGroup("A",4) gap> ReflectionLength(W,LongestCoxeterElement(W)); 2 gap> ReflectionLength(W,EltWord(W,[1,2,3,4])); 4
This function requires the package "chevie" (see RequirePackage).
ReflectionWord( W, w [, refs])
This function return a list of minimal length of reflections of which w is the product. The reflections are represented as their index in the list of reflections (which is the index of the corresponding positive root in the list of roots). If a third argument is given, it must be a list of reflections and only these reflections are tried, and the index is with respect to this list of reflections. This function works for all elements of a Coxeter group when no third argument is given, or for w a simple of the dual braid monoid if W is a well-generated complex reflection group and refs is the list of atoms of this monoid.
gap> W:=CoxeterGroup("A",4); CoxeterGroup("A",4) gap> ReflectionWord(W,LongestCoxeterElement(W)); [ 6, 10 ] gap> ReflectionWord(W,EltWord(W,[1,2,3,4])); [ 1, 2, 3, 4 ]
This function requires the package "chevie" (see RequirePackage).
77.10 HyperplaneOrbits
HyperplaneOrbits( W )
returns a list of records, one for each hyperplane orbit of W, containing the following fields for each orbit:
.s
:
.e_s
:
.classno
:w=W.generators[.s]
returns
List([1..e_s-1],i->PositionClass(W,w^i)
.N_s
:
.det_s
:[1..e_s-1]
, position in CharTable of (det_s)^i
gap> W:=CoxeterGroup("B",2); CoxeterGroup("B",2) gap> HyperplaneOrbits(W); [ rec( s := 1, e_s := 2, classno := [ 2 ], N_s := 2, det_s := [ 5 ] ), rec( s := 2, e_s := 2, classno := [ 4 ], N_s := 2, det_s := [ 1 ] ) ]
This function requires the package "chevie" (see RequirePackage).
BraidRelations( W )
this function returns the relations which present the braid group of W. These are homogeneous (both sides of the same length) relations between generators in bijection with the generating reflections of W. A presentation of W is obtained by adding relations specifying the order of the generators.
gap> W:=ComplexReflectionGroup(29); ComplexReflectionGroup(29) gap> BraidRelations(W); [ [ [ 1, 2, 1 ], [ 2, 1, 2 ] ], [ [ 2, 4, 2 ], [ 4, 2, 4 ] ], [ [ 3, 4, 3 ], [ 4, 3, 4 ] ], [ [ 2, 3, 2, 3 ], [ 3, 2, 3, 2 ] ], [ [ 1, 3 ], [ 3, 1 ] ], [ [ 1, 4 ], [ 4, 1 ] ], [ [ 4, 3, 2, 4, 3, 2 ], [ 3, 2, 4, 3, 2, 4 ] ] ]
each relation is represented as a pair of lists, specifying that the product of the generators according to the indices on the left side is equal to the product according to the indices on the right side. See also PrintDiagram.
This function requires the package "chevie" (see RequirePackage).
PrintDiagram( W )
PrintDiagram( type )
This is a purely descriptive routine, which, by printing a diagram as in BMR98 for W or the given reflection type (a Dynkin diagram for Weyl groups) shows how the generators of W are labeled in the CHEVIE presentation.
gap> PrintDiagram(ComplexReflectionGroup(31)); G31 4 - 2 - 5 \ /3\ / 1 - 3 i.e. A_4 on 14253 plus 123=231=312
This function requires the package "chevie" (see RequirePackage).
ReflectionCharValue( W, w )
Returns the trace of the element w of the reflection group W as an
endomorphism of the vector space V on which W acts. This could also
be obtained (less efficiently) by TraceMat(MatXPerm(W,w))
.
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).
ReflectionCharacter( W )
Returns the reflection character of the reflection
group W. This could also be obtained (less
efficiently) by List(ConjugacyClasses(W),c->ReflectionCharValue(W,c))
.
When W is irreducible, it can also be written
CharTable(W).irreducibles[ChevieCharInfo(W).positionRefl]
gap> W := CoxeterGroup( "A", 3 ); CoxeterGroup("A",3) gap> ReflectionCharacter(W); [ 3, 1, -1, 0, -1 ]
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 d1,...,ddim 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 := ComplexReflectionGroup(30); CoxeterGroup("H",4) gap> ReflectionDegrees( W ); [ 2, 12, 20, 30 ] gap> Size( W ); 14400
This function requires the package "chevie" (see RequirePackage).
ReflectionCoDegrees( W )
returns a list holding the codegrees of W as a reflection group on the vector space V on which it acts. These are one less than the degrees d* 1,...,d* dim V of the basic derivations of W on SV⊗ V∨, written in increasing order.
gap> W := ComplexReflectionGroup(4);; gap> ReflectionCoDegrees( W ); [ 0, 2 ]
This function requires the package "chevie" (see RequirePackage).
GenericOrder(W,q)
returns the generic order of W
in its reflection representation as a
polynomial in q
. The generic order is the Poincaré
polynomial of the polynomial invariants of W.
This function requires the package "chevie" (see RequirePackage).
TorusOrder(W,i,q)
returns the toric order of the i
-th conjugacy class of W
. This is
the characteristic polynomial (as a polynomial in q
) of an element of
the i
-th classs on the reflection representation of W
.
This function requires the package "chevie" (see RequirePackage).
Invariants( W )
returns the fundamental invariants of W in its reflection
representation V. That is, returns a set of algebraically independent
elements of the symmetric algebra of the dual of V which generate the
W-invariant polynomial functions on V. Each such invariant function
is returned as a GAP function: if e1,...,en is a basis
of V and f
is the GAP function, then the value of the
polynomial function on a1e1+...+an en is obtained by calling
f(a1,...,an). This function depends on the classification, and is
dependent on the exact reflection representation of W. So for the
moment, it is only implemented for reflection groups all of whose
irreducible components are imprimitive or of type not F4, En, Hn,
G32; further it needs that the reflection representation for the
corresponding irreducible components have the same Cartan matrix as the
one provided by CHEVIE for the corresponding irreducible group.
gap> W:=CoxeterGroup("A",2); CoxeterGroup("A",2) gap> i:=Invariants(W); [ function ( arg ) ... end, function ( arg ) ... end ] gap> x:=X(Rationals);;x.name:="x";; gap> y:=X(RationalsPolynomials);;y.name:="y";; gap> i[1](x,y); (-2*x^0)*y^2 + (2*x)*y + (-2*x^2) gap> i[2](x,y); (-6*x)*y^2 + (6*x^2)*y
This function requires the package "chevie" (see RequirePackage).
Previous Up Next
Index
GAP 3.4.4