GAP (SLA) - Chapter 2: Root Systems and Weyl Groups

Goto Chapter: Top 1 2 3 4 5 6 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

2 Root Systems and Weyl Groups
2.1 Root Systems
2.1-1 ExtendedCartanMatrix
2.1-2 CartanType
2.1-3 DisplayDynkinDiagram
2.2 Weyl groups
2.2-1 WeylTransversal
2.2-2 SizeOfWeylGroup
2.2-3 WeylGroupAsPermGroup
2.2-4 ApplyWeylPermToWeight
2.2-5 WeylWordAsPerm
2.2-6 PermAsWeylWord

### 2 Root Systems and Weyl Groups

This chapter contains the description of some functions for the objects in the title of the chapter.

#### 2.1 Root Systems

##### 2.1-1 ExtendedCartanMatrix

`‣ ExtendedCartanMatrix`( R ) | ( operation )

Here R is a root system. This function returns the extended Cartan matrix of R. That is the Cartan matrix correponding to the lowest root (coming first), and the simple roots of R.

The output is a record with components ECM (the extended Cartan matrix) and labels (the labels of the corresponding Dynkin diagram; they are the integer coefficients of a linear dependency of the roots corresponding to the nodes).

    gap> R:= RootSystem("F",4);;
    gap> ExtendedCartanMatrix(R);
    rec( ECM := [ [ 2, -1, 0, 0, 0 ], [ -1, 2, -1, 0, 0 ], [ 0, -1, 2, -2, 0 ],
          [ 0, 0, -1, 2, -1 ], [ 0, 0, 0, -1, 2 ] ], labels := [ 1, 2, 3, 4, 2 ] )

##### 2.1-2 CartanType

`‣ CartanType`( C ) | ( operation )

Here C is a Cartan matrix (i.e., an integer matrix with 2-s on the diagonal, non-positive entries otherwise, and there exists a diagonal integer matrix D such that CD is a positive definite symmetric matrix). This function returns a record with two components: types, a list containing the types of the simple components of the corresponding root system, and enumeration, a standard enumeration of the vertices of the Dynkin diagram of C. So this can be used to construct isomorphisms of root systems.

    gap> C:= [[2,0,-3,0],[0,2,0,-1],[-1,0,2,0],[0,-1,0,2]];
    [ [ 2, 0, -3, 0 ], [ 0, 2, 0, -1 ], [ -1, 0, 2, 0 ], [ 0, -1, 0, 2 ] ]
    gap> CartanType(C);
    rec( enumeration := [ [ 3, 1 ], [ 2, 4 ] ],
      types := [ [ "G", 2 ], [ "A", 2 ] ] )

##### 2.1-3 DisplayDynkinDiagram

`‣ DisplayDynkinDiagram`( C ) | ( operation )

`‣ DisplayDynkinDiagram`( R ) | ( operation )

Here C is a Cartan matrix. This function displays the Dynkin diagram of the Cartan matrix. (Remark: this just works for Cartan matrices of root systems, not for extended Cartan matrices.)

In the second form R is a root system. We display its Dynkin diagram.

    gap> C:=[[2,0,-1,0,0,0],[0,2,0,0,-3,0],[-1,0,2,0,0,-1],[0,0,0,2,0,-1],
    > [0,-1,0,0,2,0],[0,0,-2,-1,0,2]];;
    gap> DisplayDynkinDiagram(C);
    F4:  4---6=>=3---1
    G2:  5#<#2

#### 2.2 Weyl groups

##### 2.2-1 WeylTransversal

`‣ WeylTransversal`( R, inds ) | ( operation )

`‣ WeylTransversal`( R, roots ) | ( operation )

Here R is a root system, and inds a list of indices of positive roots of R that form a set of simple roots of a root subsystem of R (the system does not check this). Here an index of a positive root is its position in the list PositiveRootsNF( R ).

This function returns a list of shortest representatives of the right cosets of the corresponding Weyl subgroup of the Weyl group of R. The elements of the Weyl group are given as reduced expressions.

In the second form rts is a list of roots of R, that form a set of simple roots of a root subsystem of R (again, this is not checked). In this form the roots so not have to be positive. They have to be represented with respect to the basis of simple roots, i.e., they are elements of PositiveRootsNF(R) or of NegativeRootsNF(R).

    gap> R:= RootSystem("A",3);;
    gap> WeylTransversal( R, [2,6] );
    [ [  ], [ 1 ], [ 3 ], [ 1, 2 ], [ 1, 3 ], [ 3, 2 ] ]
    gap> R:= RootSystem("E",8);;
    gap> p:= PositiveRootsNF(R);;
    gap> a:= WeylTransversal( R, [p[1],p[3],p[4],p[5],p[6],p[7],p[8],-p[120]] );;
    gap> Length(a);
    1920

##### 2.2-2 SizeOfWeylGroup

`‣ SizeOfWeylGroup`( R ) | ( operation )

`‣ SizeOfWeylGroup`( type ) | ( operation )

`‣ SizeOfWeylGroup`( X, n ) | ( operation )

In the first from R is a root system. In the second form type is a list of lists describing the type of a root system. For example: [["A",3],["B",5],["G",2]]. In the third form X is a letter (i.e., a string) and n a positive integer, so that Xn is the type of a root system. In all cases the number of elements of the Weyl group is returned.

    gap> R:= RootSystem( SimpleLieAlgebra("E",6,Rationals) );;
    gap> SizeOfWeylGroup(R);
    51840
    gap> SizeOfWeylGroup( [["E",6]] );
    51840
    gap> SizeOfWeylGroup( "E", 6 );
    51840

##### 2.2-3 WeylGroupAsPermGroup

`‣ WeylGroupAsPermGroup`( R ) | ( operation )

Here R is a root system. This function returns a permutation group whose set of elements is in bijection with the set of elements of the Weyl group of R. More precisely, this bijection works as follows.

Let \(n\) be the number of positive roots of R. We list the positive roots in the order in which they apppear in PositiveRootsNF( R ). To this list we append the negative roots, listed in the same order. Thus the list of roots is \(\{\alpha_1,\ldots,\alpha_{2n}\} \), where \(\alpha_{i+n} = -\alpha_i\) for \(1\leq i\leq n\). Then a reflection \(s_\alpha\) corresponding to the root \(\alpha\) corresponds to the permutation \(\pi_\alpha\), where \(s_\alpha( \alpha_i ) = \alpha_{i^{\pi_\alpha}}\). Note, however, that \(s_\alpha\) acts from the left, whereas \(\pi_\alpha\) acts from the right. Let \(W\) denote the Weyl group of R and let \(G\) be the group generated by the permutations \(\pi_\alpha\) for \(\alpha\) in the fixed set of simple roots of R. Then mapping \(s_\alpha\) to \(\pi_\alpha\) extends to an anti-isomorphism \(W\to G\). The reason for doing it like this is that in the vast majority of literature on Lie theory the Weyl group acts from the left, but in GAP permutation groups act from the right. When applying the group that is output by this function this difference has to be kept in mind. For example, the orbit of a root \(\beta\) under \(W\) equals the set of images of \(\beta\) under the representatives of the left cosets of the stabilizer of \(\beta\). But when we use the group \(G\) we have to consider the right cosets for this.

    gap> R:= RootSystem("E",6);
    <root system of type E6>
    gap> G:= WeylGroupAsPermGroup( R );
    <permutation group with 6 generators>
    gap> Size(G);
    51840

##### 2.2-4 ApplyWeylPermToWeight

`‣ ApplyWeylPermToWeight`( R, p, w ) | ( operation )

Here R is a root system, p is an element of the group returned by `WeylGroupAsPermGroup` (2.2-3) with input R. Here w is a weight, that the list of coefficients of a weight when written as a linear combination of fundamental weights. This function returns the result of acting with the element of the Weyl group corresponding to p on w.

    gap> R:= RootSystem("D",4);;
    gap> G:= WeylGroupAsPermGroup(R);
    <permutation group with 4 generators>
    gap> wt:= ApplyWeylPermToWeight( R, Random(G), [1,1,1,1] );;
    gap> ConjugateDominantWeight( WeylGroup(R), wt );
    [ 1, 1, 1, 1 ]

##### 2.2-5 WeylWordAsPerm

`‣ WeylWordAsPerm`( R, u ) | ( operation )

Here R is a root system, and u is an element of the Weyl group given as a (not necessarily reduced) word, that is, u is given by a list of indices between 1 and the rank of R. This function returns the permutation corresponding to u, that is, the image of u under the anti-iromorphism discussed in `WeylGroupAsPermGroup` (2.2-3).

    gap> R:= RootSystem("D",4);;
    gap> WeylWordAsPerm( R, [1,2,1,3,4,2,3,4,1] );
    (1,23,12,17)(2,10,14,22)(3,19,16,6)(4,18,15,7)(5,13,11,24)(8,21)(9,20)

##### 2.2-6 PermAsWeylWord

`‣ PermAsWeylWord`( R, p ) | ( operation )

This is the inverse operation to the one discussed in `WeylWordAsPerm` (2.2-5). That is, the element of the Weyl group (this time given as reduced expression) corresponding to the permutation p is returned.

In the next example we compute generators of the stabilizer of a subset of a root system. The generators are given as reduced words.

    gap> R:= RootSystem("D",4);;
    gap> rts:= [1,3,4,12,13,15,16,24];;
    gap> G:= WeylGroupAsPermGroup(R);;
    gap> S:= Stabilizer( G, rts, OnSets );
    <permutation group of size 64 with 6 generators>
    gap> Size(S);
    64
    gap> List( GeneratorsOfGroup(S), g -> PermAsWeylWord( R, g ) );
    [ [ 3 ], [ 3, 4 ], [ 2, 1, 3, 2, 4, 2, 1, 3, 2, 4 ], [ 2, 1, 3, 2 ],
      [ 2, 1, 4, 2 ], [ 1, 3 ] ]

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 Bib Ind

generated by GAPDoc2HTML