84 Finite Reflection Groups

Let W be a finite reflection group on the vector space V over a subfield k 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 and coroot vectors for reflections of W; that is, a set R of pairs (r,r)∈ V× V* invariant by W and such that all reflections in W are the reflections with root r and coroot r for some pair in R (see Reflection). This generalizes the usual construction for Coxeter groups (the special case k=ℝ) where to each reflection of W is associated two roots, a positive and a negative one. For complex reflection groups, more roots may lie on the same line --- we need at least as many as the order of the center of W. There is not yet a general theory on how to construct a nice set of roots for a non-real reflection group; the roots chosen in CHEVIE where obtained case-by-case; however, they satisfy several important properties:

• The generating reflections satisfy braid relations which present the braid group associated to W (see PrintDiagram).

• The field of definition of W is the field k generated by the traces of the elements of W acting on V. In CHEVIE, in almost all cases, all the matrices for elements of W have coefficients in k. Further, this set of matrices is globally invariant under the Galois group of k/ℚ, thus the Galois action induces automorphisms of W. The exceptions are G22, G27 where the matrices are in a degree two extension of k (this is needed to have a globally invariant model, see MarinMichel10) and some dihedral groups, where the matrices given (the usual model over k) are nor globally invariant. A degree 2 extension would be needed for an invariant model.

• The Cartan matrix (see CartanMat) for the generating roots has entries in the ring k of integers of k, and the roots (resp. coroots) are linear combination with coefficients in k of a linearly independent subset of them.

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 names which range from G4 to G37. They cover the exceptional Coxeter groups, e.g., CoxeterGroup("E",8) is the same as G37.

CHEVIE provides functions to build any finite reflection group, described in terms of the classification, or given 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).

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:

a set of complex roots in V, given as a matrix, on which W has a faithful permutation representation.

simpleCoroots:

the coroots for the first .nbGeneratingReflections roots.

In this chapter we describe functions available for finite reflection groups W represented as permutation groups on a set of roots. These functions make use of the classification of W 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 χ.

It turns out that all representations of a complex reflection group W are defined over the field of definition of W (cf. Ben76 and D. Bessis thesis). This has been known for a long time in the case k=ℚ, the case of Weyl groups: their representations are defined over the rationals.

Subsections

  1. Functions for finite reflection groups
  2. PermRootGroup
  3. ReflectionType
  4. ReflectionName
  5. IsomorphismType
  6. ComplexReflectionGroup
  7. Reflections
  8. MatXPerm
  9. PermMatX
  10. MatYPerm
  11. InvariantForm for finite reflection groups
  12. ReflectionEigenvalues
  13. ReflectionLength
  14. ReflectionWord
  15. HyperplaneOrbits
  16. BraidRelations
  17. PrintDiagram
  18. ReflectionCharValue
  19. ReflectionCharacter
  20. ReflectionDegrees
  21. ReflectionCoDegrees
  22. GenericOrder
  23. TorusOrder
  24. ParabolicRepresentatives for reflection groups
  25. Invariants

84.1 Functions for finite reflection groups

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.

EltWord:

Works like for Coxeter groups; in addition, as a special convention, if all .reflectionsLabels of W are positive integers, negative integers are accepted and represent the inverse of the corresponding generator.

*:

A*B returns the product of the two reflection groups A and B as a reflection group.

84.2 PermRootGroup

PermRootGroupNC( roots [,eigenvalues]) PermRootGroup( roots [,eigenvalues])

PermRootGroupNC( roots, coroots) 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 GAP3 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).

In the (faster) variant with NC, the group is not classified (thus for instance PrintDiagram will not work).

    gap> W:=PermRootGroupNC(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> PrintDiagram(W);
    Error, PermRootGroup([ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
      [ [ 2, -1, 0 ], [ -1, 2, -1 ], [ 0, -1, 2 ] ]) has no method 
    for PrintDiagram in
    Dispatcher( "PrintDiagram" )( W ) called from
    PrintDiagram( W ) called from
    main loop
    brk> 
    gap> ReflectionType(W);
    [ rec(rank := 3,
          series := "A",
          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]])
    gap> ReflectionDegrees(W);
    [ 2, 3, 4 ]

84.3 ReflectionType

ReflectionType( W )

This function returns the type of W, which is a list each element of which describes an irreducible component of W; the elements of the list are objects of type Reflection Type, on which some functions can be called to obtain data on groups of that type, like ReflectionDegrees, etc...

Such an object is a record with a field series, the type ("A", "B", "D", etc...) of the component, a field indices, the indices in the list of generating reflections of W where it sits, a field rank (equal to Length(indices) for well-generated complex reflection groups such as Coxeter groups, and to Length(indices)+1 for the others).

For dihedral groups there is in addition a field bond giving the order of the braid relation between the two generators.

For complex reflection groups which are not real, the field series is equal to "ST", and there is an additional field ST, equal either to 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 upon construction of a finite reflection group via PermRootGroup, or upon constructing a finite Coxeter group by CoxeterGroup. But since it is sometimes costly in time (it identifies the type of the group based on the order, the degree, the order of the generators and the Cartan matrix; sometimes it needs to search for another set of generators than the given one), a version PermRootGroupNC is given which does not call it.

This function is called automatically prior to calling any function depending on the classification, such as PrintDiagram, ReflectionName, ChevieClassInfo, BraidRelations, CharName, CharParams, Representations, Invariants.

    gap> W:=ComplexReflectionGroup(4)*CoxeterGroup("A",2);;
    gap> ReflectionType(W);
    [ rec(series  := "ST",
          ST      := 4,
          rank    := 2,
          indices := [ 1, 2 ]), rec(rank    := 2,
          series  := "A",
          indices := [ 3, 4 ]) ]

ReflectionType( C )

C should be a Cartan matrix. This function determines the type of each irreducible component of C which is the Cartan matrix of a finite Coxeter group; the result is a list of Reflection types. The corresponding field is set to false if the corresponding submatrix of C is not the Cartan matrix of a finite Coxeter group. Going from the above example:

    gap> C:=CartanMat(W);
    [ [ -2*E(3)-E(3)^2, E(3)^2, 0, 0 ], [ -E(3)^2, -2*E(3)-E(3)^2, 0, 0 ],
      [ 0, 0, 2, -1 ], [ 0, 0, -1, 2 ] ]
    gap> ReflectionType(C);
    [ false, rec(rank    := 2,
          series  := "A",
          indices := [ 3, 4 ]) ]

Note that a Cartan matrix for a finite Coxeter group is conjugate by a diagonal matrix of the matrices for the root systems given in the introduction of the chapter on root systems. This conjugation corresponds to changing the ratio of the length between long and short roots; for example one could construct a root system for type B where the quotient of the two root lengths is any cyclotomic number.

    gap> M:=[ [ 2, -E(7)^3-E(7)^5-E(7)^6 ], [ -E(7)-E(7)^2-E(7)^4, 2 ] ];;
    gap> ReflectionType(M);
    [ rec(rank       := 2,
          series     := "B",
          cartanType := E(7)^3+E(7)^5+E(7)^6,
          indices    := [ 1, 2 ]) ]

In the above example, the cartanType field shows that the two root lengths for B2 have a ratio which is (1+√-7)/(2).

84.4 ReflectionName

ReflectionName( type )

takes as argument a type type as returned by ReflectionType. Returns the name of the group system with that type, which is the concatenation of the names of its irreducible components, with x added in between. For reflection subgroups, it gives an indication about embedding in the parent

    gap> C := [ [ 2, 0, -1 ], [ 0, 2, 0 ], [ -1, 0, 2 ] ];;
    gap> ReflectionName( ReflectionType( C ) );
    "A2xA1"
    gap> ReflectionName( ReflectionType( CartanMat( "I", 2, 7 ) ) );
    "I2(7)"
    gap> ReflectionName(ReflectionSubgroup(CoxeterGroup("E",8),[2,3,6,7]));
    "A1<2>xA1<3>xA2<6,7>.(q-1)^4"

ReflectionName( D )

The argument to ReflectionType can also be a record with a field operations.ReflectionType, and that function is then called with rec as argument --- this works for reflection groups and reflection cosets.

84.5 IsomorphismType

IsomorphismType( W )

takes as argument a reflection group or a reflection coset. Returns a description of the isomorphism type of the argument.

    gap> IsomorphismType(ReflectionSubgroup(CoxeterGroup("E",8),[2,3,6,7]));
     "A2+2A1"

84.6 ComplexReflectionGroup

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)

84.7 Reflections

Reflections( W )

returns the list of distinguished reflections of W, as elements of W. We recall that a reflection is distinguished (see "Reflections, and reflection groups") if it has eigenvalue E(e) where e is the cardinality of the cyclic subgroup CW(H), where H is the hyperplane of fixed points of the reflection (all reflections are distinguished if W is generated by reflections of order 2). The generating reflections of W are Reflections(W){W.generatingReflections}.

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

the code needed to obtain in general all reflections of W (not only the distinguished ones) is:

    gap> l:=Reflections(W);;
    gap> l:=Concatenation(List(l,s->List([1..Order(W,s)-1],i->s^i)));;

for finite Coxeter groups, Reflections(W) are in the same order as the positive roots. For general complex reflection groups the relationship with roots is only guaranteed for the generating reflections, that is Reflections(W){W.generatingReflections} are the reflections with respect to W.roots{W.generatingReflections}. The other reflections are not in the same order as the roots.

84.8 MatXPerm

MatXPerm( W, w )

Let w be a permutation of the roots of the finite reflection group W with reflection representation V. The function MatXPerm returns the matrix of w acting on V. This is the linear transformation of V which acts trivially on the orthogonal of the coroots and has same effect as w on the simple roots. 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 ] ] 

84.9 PermMatX

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

84.10 MatYPerm

MatYPerm( W, w )

Let w be a permutation of the roots of the finite reflection group W with reflection representation V. The function MatYPerm returns the matrix of w acting on the dual vector space V. This is the linear transformation of V which acts trivially on the orthogonal of the roots and has same effect as w on the simple coroots. The function makes sense more generally for an element of the normalizer of W in the whole permutation group of the roots.

    gap>  W:=ReflectionSubgroup(CoxeterGroup("E",7),[1..6]);
    ReflectionSubgroup(CoxeterGroup("E",7), [ 1, 2, 3, 4, 5, 6 ])
    gap>  w0:=LongestCoxeterElement(W);;
    gap> my:=MatYPerm(W,w0);
    [ [ 0, 0, 0, 0, 0, -1, 2 ], [ 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, 2 ],
      [ 0, 0, 0, 0, 0, 0, 1 ] ]

84.11 InvariantForm for finite reflection groups

InvariantForm( W )

This function returns the matrix F of an Hermitian form invariant under the action of the reflection group W. That is, if M is the matrix of an element of W, then M*F*Transpose(ComplexConjugate(M))=F.

    gap> W:=ComplexReflectionGroup(4);
    ComplexReflectionGroup(4)
    gap> F:=InvariantForm(W);
    [ [ 1, 0 ], [ 0, 2 ] ]
    gap> List(W.matgens,m->m*F*ComplexConjugate(TransposedMat(m))=F);
    [ true, true ]

84.12 ReflectionEigenvalues

ReflectionEigenvalues( W [, c])

Let W be a reflection group on the vector space V. ReflectionEigenvalues( W) returns the list for each conjugacy classes 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 GAP3 it is trivial to compute E(n)^i given i/n, but the converse is more expensive). 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 ]
    gap> ReflectionEigenvalues(CoxeterGroup("B",2));
    [ [ 0, 0 ], [ 1/2, 0 ], [ 1/2, 1/2 ], [ 1/2, 0 ], [ 1/4, 3/4 ] ]

84.13 ReflectionLength

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

84.14 ReflectionWord

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 ]

84.15 HyperplaneOrbits

HyperplaneOrbits( W )

returns a list of records, one for each hyperplane orbit of W, containing the following fields for each orbit:

.s:

index of first generator in orbit

.e_s:

order of s

.classno:

if w=W.generators[.s] returns List([1..e_s-1],i->PositionClass(W,w^i)

.N_s:

Size of orbit

.det_s:

for i in [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 ] ) ]

84.16 BraidRelations

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.

84.17 PrintDiagram

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

84.18 ReflectionCharValue

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, 1, 0, 0, 0, -1, 0, -1, -1, 1, 1, -1, -1, -1, 0, 0, 0, 0,
      -1, -1, 1, -1 ] 

84.19 ReflectionCharacter

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).extRefl[2]]

    gap> W := CoxeterGroup( "A", 3 );
    CoxeterGroup("A",3)
    gap> ReflectionCharacter(W);
    [ 3, 1, -1, 0, -1 ] 

84.20 ReflectionDegrees

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,...,d dim V of the basic invariants of W in SV. 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 

84.21 ReflectionCoDegrees

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.

    gap> W := ComplexReflectionGroup(4);;
    gap> ReflectionCoDegrees( W );
    [ 0, 2 ]

84.22 GenericOrder

GenericOrder(W,q)

returns the "compact" generic order of W as a polynomial in q. This is qNhi(qdi-1) where di are the reflection degrees and Nh the number of reflecting hyperplanes. For a Weyl group, it is the order of the associated semisimple finite reductive group over the field with q elements.

    gap> q:=X(Rationals);;q.name:="q";;
    gap> GenericOrder(ComplexReflectionGroup(4),q);
    q^14 - q^10 - q^8 + q^4

84.23 TorusOrder

TorusOrder(W,i,q)

returns as a polynomial in q the toric order of the i-th conjugacy class of W. This is the characteristic polynomial of an element of that class on the reflection representation of W. It is the same as the generic order of the reflection subcoset of W determined by the trivial subgroup and a representative of the i-th conjugacy class.

    gap> W:=ComplexReflectionGroup(4);;
    gap> q:=X(Cyclotomics);;q.name:="q";;
    gap> List([1..NrConjugacyClasses(W)],i->TorusOrder(W,i,q));
    [ q^2 - 2*q + 1, q^2 + 2*q + 1, q^2 + 1, q^2 + (-E(3))*q + (E(3)^2),
      q^2 + (E(3))*q + (E(3)^2), q^2 + (E(3)^2)*q + (E(3)),
      q^2 + (-E(3)^2)*q + (E(3)) ]

84.24 ParabolicRepresentatives for reflection groups

ParabolicRepresentatives(W [, r])

Returns a list of subsets of W.reflectionsLabels describing representatives of orbits of parabolic subgroups under conjugation by W. If a second argument r is given, returns only representatives of the parabolic subgroups of semisimple rank r. Contrary to the case of Coxeter groups, it may happen that for some orbits no representative can be chosen all of whose elements are standard generators.

    gap> ParabolicRepresentatives(ComplexReflectionGroup(3,3,3));
    [ [  ], [ 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 20 ], [ 2, 3 ], [ 1, 2, 3 ] ]
    gap> ParabolicRepresentatives(ComplexReflectionGroup(3,3,3),2);
    [ [ 1, 2 ], [ 1, 3 ], [ 1, 20 ], [ 2, 3 ] ]

84.25 Invariants

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 GAP3 function: if e1,...,en is a basis of V and f is the GAP3 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 when the reflection representation for the irreducible components has the same Cartan matrix as the one provided by CHEVIE for the corresponding irreducible group. The polynomials are invariant for the natural action of the group elements as matrices; that is, if m is MatXPerm(W,w) for some w in W, then an invariant f satisfies f(a1,...,an)= f(v1,...,vn) where [v1,...,vn]=[a1,...,an]× m. This action is implemented on Mvps by the function OnPolynomials (see OnPolynomials).

    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

Another example using Mvp from the package VKCURVE.

    gap> W:=ComplexReflectionGroup(24);;
    gap> i:=Invariants(W);;
    gap> v:=List([1..3],i->Mvp(SPrint("x",i)));
    [ x1, x2, x3 ]
    gap> ApplyFunc(i[1],v);
    -42x1^2x2x3-12x1^2x2^2+21/2x1^2x3^2-9/2x2^2x3^2-6x2^3x3+14x1^4+18/7x2^\ 
    4-21/8x3^4
    gap> OnPolynomials(W.matgens[1],last)-last;
    0

Previous Up Next
Index

gap3-jm
08 Sep 2017