60.7 Semisimple Lie Algebras and Root Systems

Let L be a semisimple Lie algebra, i.e., a direct sum of simple Lie algebras. Then SemiSimpleType returns the type of L, i.e., a string containing the types of the simple summands of L.

gap> L:= SimpleLieAlgebra( "E", 8, Rationals );;
gap> b:= BasisVectors( Basis( L ) );;
gap> K:= LieCentralizer( L, Subalgebra( L, [ b[61]+b[79]+b[101]+b[102] ] ) );
<Lie algebra of dimension 102 over Rationals>
gap> lev:= LeviMalcevDecomposition(K);; 
gap> SemiSimpleType( lev[1] );
"B3 A1"

Here L must be a semisimple Lie algebra with a split Cartan subalgebra. Then ChevalleyBasis( L ) returns a list consisting of three sublists. Together these sublists form a Chevalley basis of L. The first list contains the positive root vectors, the second list contains the negative root vectors, and the third list the Cartan elements of the Chevalley basis.

gap> L:= SimpleLieAlgebra( "G", 2, Rationals );
<Lie algebra of dimension 14 over Rationals>
gap> ChevalleyBasis( L );
[ [ v.1, v.2, v.3, v.4, v.5, v.6 ], [ v.7, v.8, v.9, v.10, v.11, v.12 ], 
  [ v.13, v.14 ] ]

Category of root systems.

Category of root systems that come from (semisimple) Lie algebras. They often have special attributes such as UnderlyingLieAlgebra, PositiveRootVectors, NegativeRootVectors, CanonicalGenerators.

RootSystem calculates the root system of the semisimple Lie algebra L with a split Cartan subalgebra.

gap> L:= SimpleLieAlgebra( "G", 2, Rationals );
<Lie algebra of dimension 14 over Rationals>
gap> R:= RootSystem( L );
<root system of rank 2>
gap> IsRootSystem( R );
true
gap> IsRootSystemFromLieAlgebra( R );
true

Here R is a root system coming from a semisimple Lie algebra L. This function returns L.

The list of positive roots of the root system R.

The list of negative roots of the root system R.

A list of positive root vectors of the root system R that comes from a Lie algebra L. This is a list in bijection with the list PositiveRoots( L ). The root vector is a non-zero element of the root space (in L) of the corresponding root.

A list of negative root vectors of the root system R that comes from a Lie algebra L. This is a list in bijection with the list NegativeRoots( L ). The root vector is a non-zero element of the root space (in L) of the corresponding root.

A list of simple roots of the root system R.

The Cartan matrix of the root system R, relative to the simple roots in SimpleSystem( R ).

The matrix of the bilinear form of the root system R. If we denote this matrix by B, then we have B(i,j) = (a_i,a_j), where the a_i are the simple roots of R.

Here R must be a root system coming from a semisimple Lie algebra L. This function returns 3l generators of L, x₁, ¼, x_l,y₁, ¼, y_l,h₁,¼, h_l, where x_i lies in the root space corresponding to the i-th simple root of the root system of L, y_i lies in the root space corresponding to - the i-th simple root, and the h_i are elements of the Cartan subalgebra. These elements satisfy the relations h_i*h_j = 0, x_i*y_j = d_ijh_i, h_j*x_i = c_ij x_i, h_j*y_i = -c_ij y_i, where c_ij is the entry of the Cartan matrix on position ij.

Also if a is a root of the root system R (so a is a list of numbers), then we have the relation h_i*x = a[i] x, where x is a root vector corresponding to a.

gap> L:= SimpleLieAlgebra( "G", 2, Rationals );;
gap> R:= RootSystem( L );;
gap> UnderlyingLieAlgebra( R );
<Lie algebra of dimension 14 over Rationals>
gap> PositiveRoots( R );
[ [ 2, -1 ], [ -3, 2 ], [ -1, 1 ], [ 1, 0 ], [ 3, -1 ], [ 0, 1 ] ]
gap> x:= PositiveRootVectors( R );
[ v.1, v.2, v.3, v.4, v.5, v.6 ]
gap> g:=CanonicalGenerators( R );
[ [ v.1, v.2 ], [ v.7, v.8 ], [ v.13, v.14 ] ]
gap> g[3][1]*x[1];
(2)*v.1
gap> g[3][2]*x[1];
(-1)*v.1
# i.e., x[1] is the root vector belonging to the root [ 2, -1 ]
gap> BilinearFormMat( R );
[ [ 1/12, -1/8 ], [ -1/8, 1/4 ] ]

The next few sections deal with the Weyl group of a root system. A Weyl group is represented by its action on the weight lattice. A it weight is by denition a linear function l: H® F (where F is the ground field), such that the values l(h_i) are all integers (where the h_i are the Cartan elements of the CanonicalGenerators). On the other hand each weight is determined by these values. Therefore we represent a weight by a vector of integers; the i-th entry of this vector is the value l(h_i). Now the elements of the Weyl group are represented by matrices, and if g is an element of a Weyl group and w a weight, then w*g gives the result of applying g to w. Another way of applying the i-th simple reflection to a weight is by using the function ApplySimpleReflection (see below).

A Weyl group is generated by the simple reflections. So GeneratorsOfGroup( W ) for a Weyl group W gives a list of matrices and the i-th entry of this list is the simple reflection corresponding to the i-th simple root of the corresponding root system.

A Weyl group is a group generated by reflections, with the attribute SparseCartanMatrix set.

This is a sparse form of the Cartan matrix of the corresponding root system. If we denote the Cartan matrix by C, then the sparse Cartan matrix of W is a list (of length equal to the length of the Cartan matrix), where the i-th entry is a list consisting of elements [ j, C[i][j] ], where j is such that C[i][j] is non-zero.

The Weyl group of the root system R. It is generated by the simple reflections. A simple reflection is represented by a matrix, and the result of letting a simple reflection m act on a weight w is obtained by w*m.

gap> L:= SimpleLieAlgebra( "F", 4, Rationals );;
gap> R:= RootSystem( L );;
gap> W:= WeylGroup( R );
<matrix group with 4 generators>
gap> IsWeylGroup( W );
true
gap> SparseCartanMatrix( W );
[ [ [ 1, 2 ], [ 3, -1 ] ], [ [ 2, 2 ], [ 4, -1 ] ], 
  [ [ 1, -1 ], [ 3, 2 ], [ 4, -1 ] ], [ [ 2, -1 ], [ 3, -2 ], [ 4, 2 ] ] ]
gap> g:= GeneratorsOfGroup( W );;
gap> [ 1, 1, 1, 1 ]*g[2];
[ 1, -1, 1, 2 ]

Here SC is the sparse Cartan matrix of a Weyl group. This function applies the i-th simple reflection to the weight wt, thus changing wt.

gap> L:= SimpleLieAlgebra( "F", 4, Rationals );;
gap> W:= WeylGroup( RootSystem( L ) );;
gap> C:= SparseCartanMatrix( W );;
gap> w:= [ 1, 1, 1, 1 ];;
gap> ApplySimpleReflection( C, 2, w );             
gap> w;
[ 1, -1, 1, 2 ]

Let g₀ be the longest element in the Weyl group W, and let {a₁,¼, a_l} be a simple system of the corresponding root system. Then g₀ maps a_i to -a_s(i), where s is a permutation of (1,¼,l). This function returns that permutation.

gap> L:= SimpleLieAlgebra( "E", 6, Rationals );;
gap> W:= WeylGroup( RootSystem( L ) );;
gap> LongestWeylWordPerm( W );
(1,6)(3,5)

Here W is a Weyl group and wt a weight (i.e., a list of integers). This function returns the usnique dominant weight conjugate to wt under W.

ConjugateDominantWegihtWithWord( W, wt ) returns a list of two elements. The first of these is the dominant weight conjugate do wt. The second element is a list of indices of simple reflections that have to be applied to wt in order to get the dominant weight conjugate to it.

gap> L:= SimpleLieAlgebra( "E", 6, Rationals );;
gap> W:= WeylGroup( RootSystem( L ) );;
gap> C:= SparseCartanMatrix( W );;
gap> w:= [ 1, -1, 2, -2, 3, -3 ];;
gap> ConjugateDominantWeight( W, w );
[ 2, 1, 0, 0, 0, 0 ]
gap> c:= ConjugateDominantWeightWithWord( W, w );
[ [ 2, 1, 0, 0, 0, 0 ], [ 2, 4, 2, 3, 6, 5, 4, 2, 3, 1 ] ]
gap> for i in [1..Length(c[2])] do
> ApplySimpleReflection( C, c[2][i], w );
> od;
gap> w;
[ 2, 1, 0, 0, 0, 0 ]

Returns an iterator for the orbit of the weight wt under the action of the Weyl group W.

gap> L:= SimpleLieAlgebra( "E", 6, Rationals );;
gap> W:= WeylGroup( RootSystem( L ) );;
gap> orb:= WeylOrbitIterator( W, [ 1, 1, 1, 1, 1, 1 ] );
<iterator>
gap> NextIterator( orb );
[ 1, 1, 1, 1, 1, 1 ]
gap> NextIterator( orb );
[ -1, -1, -1, -1, -1, -1 ]
gap> orb:= WeylOrbitIterator( W, [ 1, 1, 1, 1, 1, 1 ] );
<iterator>
gap> k:= 0;
0
gap> while not IsDoneIterator( orb ) do
> w:= NextIterator( orb ); k:= k+1;
> od;
gap> k;
51840    # i.e., the size of the Weyl group of E6.

[Top] [Previous] [Up] [Next] [Index]