5 Semisimple Subalgebras of Semisimple Lie Algebras

5.2 Constructing Semisimple Subalgebras

5.2-1 RegularSemisimpleSubalgebras

5.2-2 SSSTypes

5.2-3 LieAlgebraAndSubalgebras

5.2-4 InclusionsGraph

5.2-5 SubalgebrasInclusion

5.2-6 DynkinIndex

5.2-7 AreLinearlyEquivalentSubalgebras

5.2-8 MakeDatabaseEntry

5.2-9 ClosedSubsets

5.2-10 DecompositionOfClosedSet

5.2-11 IsSpecialClosedSet

5.2-12 LieAlgebraOfClosedSet

5.2-1 RegularSemisimpleSubalgebras

5.2-2 SSSTypes

5.2-3 LieAlgebraAndSubalgebras

5.2-4 InclusionsGraph

5.2-5 SubalgebrasInclusion

5.2-6 DynkinIndex

5.2-7 AreLinearlyEquivalentSubalgebras

5.2-8 MakeDatabaseEntry

5.2-9 ClosedSubsets

5.2-10 DecompositionOfClosedSet

5.2-11 IsSpecialClosedSet

5.2-12 LieAlgebraOfClosedSet

This chapter contains functions for dealing with semisimple subalgebras of semisimple Lie algebras. There are functions for computing branching rules, for computing the regular subalgebras, and for working with the database of semisimple subalgebras of the simple Lie algebras. This last database contains the semisimple subalgebras of the simple Lie algebras of ranks up to 8. The semisimple subalgebras are classified up to linear equivalence. (Two subalgebras are called linearly equivalent if for every representation of the big algebra in the space V the images of the subalgebras are conjugate under GL(V).)

`‣ ProjectionMatrix` ( L, K ) | ( operation ) |

Here `L` and `K` are semisimple Lie algebras with the following properties: `K` is contained in `L`, the Cartan subalgebra of `L`, as returned by `CartanSubalgebra(L)` is split (this is automatic if `L` is created by the built in **GAP** function) and `K` has a Cartan subalgebra that is a subalgebra of the Cartan subalgebra of `L`. We note that the function checks only the last property. The function returns a matrix `P` such that if `u` is a weight of a `L`-module V, then `P*u` is a weight of `V`, when considered as a `K`-module.

gap> L:= SimpleLieAlgebra("E",7,Rationals);; gap> K:= Subalgebra( L, [ L.1,L.3,L.4,L.5,L.6,L.7,L.63, > L.64,L.66,L.67,L.68,L.69,L.70,L.126] );; gap> Dimension(K); 63 gap> SemiSimpleType(K); "A7" gap> ProjectionMatrix( L, K ); [ [ 2, 2, 3, 4, 3, 2, 1 ], [ 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 ], [ -1, -2, -2, -3, -2, -1, 0 ] ]

`‣ Branching` ( L, K, hw ) | ( operation ) |

`‣ Branching` ( L, K, cc, hw ) | ( operation ) |

Here `L` and `K` are as in the previous function, and `hw` is the highest weight of an irreducible `L`-module. This function computes the splitting of the module when seen as a `K`-module. Returned is a list of two lists: the first list contains the highest weights of the modules involved, the second list contains their multiplicities. In the second form the subalgebra is reductive rather than semisimple. Here `K` is again a semisimple subalgebra, and `cc` is a list of toral elements centralizing `K`. These toral elements must lie in the given Cartan subalgebra of `L`. The reductive subalgebra is the direct sum of `K` and the subalgebra spanned by the elements of `cc`. The output is the same as in the first form. However, the last t coordinates of the weights give the eigenvalues of the toral elements in `cc` on the irreducible modules.

gap> L:= SimpleLieAlgebra("E",7,Rationals);; gap> K:= Subalgebra( L, [ L.1,L.3,L.4,L.5,L.6,L.7,L.63, > L.64,L.66,L.67,L.68,L.69,L.70,L.126] );; gap> Branching( L, K, [1,0,0,0,0,0,1] ); [ [ [ 1, 1, 0, 0, 0, 0, 1 ], [ 1, 1, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 1 ], [ 0, 0, 1, 0, 1, 0, 0 ], [ 1, 0, 0, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 0, 1 ], [ 0, 0, 1, 0, 0, 0, 0 ] ], [ 1, 1, 1, 1, 1, 1, 1, 1 ] ] gap> L:= SimpleLieAlgebra("E",7,Rationals);; gap> r:= RegularSemisimpleSubalgebras(L);; gap> K:= Filtered( r, M -> SemiSimpleType(M)="E6" )[1]; <Lie algebra of dimension 78 over Rationals> gap> cc:= BasisVectors( Basis( LieCentralizer( L, K ) ) ); [ v.127+(3/2)*v.128+(2)*v.129+(3)*v.130+(5/2)*v.131+(2)*v.132+(3/2)*v.133 ] gap> Branching( L, K, cc, [1,0,0,0,0,0,1] ); [ [ [ 0, 0, 0, 0, 0, 2, -1/2 ], [ 1, 1, 0, 0, 0, 0, -1/2 ], [ 0, 0, 0, 0, 1, 0, -1/2 ], [ 1, 0, 0, 0, 0, 0, 5/2 ], [ 0, 1, 0, 0, 0, 1, 1/2 ], [ 2, 0, 0, 0, 0, 0, 1/2 ], [ 0, 0, 1, 0, 0, 0, 1/2 ], [ 0, 0, 0, 0, 0, 1, -5/2 ], [ 1, 0, 0, 0, 0, 1, -3/2 ], [ 1, 0, 0, 0, 0, 1, 3/2 ], [ 0, 1, 0, 0, 0, 0, 3/2 ], [ 0, 1, 0, 0, 0, 0, -3/2 ], [ 0, 0, 0, 0, 0, 0, 3/2 ], [ 0, 0, 0, 0, 0, 0, -3/2 ], [ 0, 0, 0, 0, 0, 1, 1/2 ], [ 1, 0, 0, 0, 0, 0, -1/2 ] ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 ] ]

`‣ RegularSemisimpleSubalgebras` ( L ) | ( attribute ) |

Here `L` is a *simple* Lie algebra. This function returns a list of its conjugacy classes of semisimple subalgebras (conjugacy under the adjoint group).

gap> L:= SimpleLieAlgebra("E",6,Rationals);; gap> K:= RegularSemisimpleSubalgebras( L );; gap> Length(K); 19 gap> K[5]; <Lie algebra of dimension 45 over Rationals> gap> SemiSimpleType( K[5] ); "D5" gap> Branching( L, K[5], [1,0,0,0,0,1] ); [ [ [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 1 ], [ 1, 0, 0, 1, 0 ], [ 1, 0, 0, 0, 1 ], [ 2, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 1 ], [ 0, 1, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ] ], [ 2, 1, 1, 1, 1, 1, 1, 1, 1 ] ]

`‣ SSSTypes` ( ) | ( function ) |

This returns a list of the types of the semisimple Lie algebras of which the database contains the classification of the semisimple subalgebras, up to linear equivalence. (The three letters S stand for SemiSimple Subalgebras.)

`‣ LieAlgebraAndSubalgebras` ( type ) | ( operation ) |

Here `type` is a string describing the type of a semisimple Lie algebra. A simple type is a capital letter (A, B, C, D, E, F, or G) followed by a positive integer. Example: `"D5"`. In general a type is a sequence of simple types separated by spaces. Example: `"A2 C3 E6"`. This function is appliccable if each simple type that occurs in `type` has rank less than or equal to 8. In that case a record is returned with two components: `liealg`, which is a semisimple Lie algebra of type `type`, and `subalgs` which is the list of its semisimple subalgebras up to linear equivalence. If `type` is a simple type then the list will be simply fetched from the database. Otherwise a computation will be triggered, and afterwards the database will be bigger. (One can check this with a call to `SSSTypes()`). Also we remark that for non-simple types of not so small rank this computation can be difficult.

`‣ InclusionsGraph` ( type ) | ( operation ) |

Here `type` is a string describing the type of a semisimple Lie algebra. This is the same as in the previous function. This function returns a list containing the edges of the inclusion graph of the semisimple subalgebras returned by the previous function. An edge is represented by a list of two integers. If the edge `[ i, j ]` occurs, then this means that the subalgebra on position `j` in the list is linearly equivalent to a subalgebra of the subalgebra in position `i`. Only the maximal subalgebras are considered; so if we have edges `[ i, j ]` and `[ j, k ]` then there will be no edge `[ i, k ]`. (Otherwise this list can become huge.) Edges of the form `[ 0, j ]` express that the subalgebra on position `j` is a maximal semisimple subalgebra of the Lie algebra of type `type`.

# Semisimple subalgebras of the Lie algebra of type D4: gap> s:= LieAlgebraAndSubalgebras( "D4" );; gap> L:= s.liealg; <Lie algebra of dimension 28 over CF(3)> gap> sub:= s.subalgs;; gap> Length(sub); 44 gap> g:= InclusionsGraph( "D4" );; gap> g[1]; [ 12, 1 ] # Find the maximal semisimple subalgebras: gap> m:= Filtered( g, x -> x[1]=0 );; i:= List( m, x -> x[2] ); [ 13, 35, 36, 37, 41, 42, 43, 44 ] gap> List( sub{i}, SemiSimpleType ); [ "A2", "A1 B2", "A1 B2", "A1 B2", "B3", "B3", "B3", "A1 A1 A1 A1" ] # We see that the subalgebras on positions 35 and 36 are isomorphic; # however they are not linearly equivalent: gap> Branching( L, sub[35], [0,0,1,0] ); [ [ [ 1, 0, 1 ] ], [ 1 ] ] gap> Branching( L, sub[36], [0,0,1,0] ); [ [ [ 0, 1, 0 ], [ 2, 0, 0 ] ], [ 1, 1 ] ]

`‣ SubalgebrasInclusion` ( L, K1, K2 ) | ( operation ) |

Here `K1`, `K2`, are two subalgebras of the semisimple Lie algebra `L`, constructed using the database. If `K2` contains a subalgebra that is linearly equivalent to `K1` then such a subalgebra is returned. Otherwise the result is `fail`.

gap> s:= LieAlgebraAndSubalgebras( "C3" );; gap> g:= InclusionsGraph( "C3" ); [ [ 10, 1 ], [ 11, 1 ], [ 12, 1 ], [ 8, 2 ], [ 10, 2 ], [ 11, 2 ], [ 11, 3 ], [ 13, 3 ], [ 8, 4 ], [ 13, 4 ], [ 9, 5 ], [ 12, 5 ], [ 12, 6 ], [ 13, 6 ], [ 0, 7 ], [ 0, 8 ], [ 15, 9 ], [ 9, 10 ], [ 14, 10 ], [ 14, 11 ], [ 15, 12 ], [ 0, 13 ], [ 15, 14 ], [ 0, 15 ] ] gap> # there are the edges [ 14, 10] and [ 10, 2 ]; hence a conjugate of the gap> # second algebra is contained in the 14-th. gap> L:= s.liealg; <Lie algebra of dimension 21 over Rationals> gap> sub:= s.subalgs;; gap> K:=SubalgebrasInclusion( L, sub[2], sub[14] ); <Lie algebra of dimension 3 over Rationals> gap> Basis(K)[1] in sub[14]; true

`‣ DynkinIndex` ( K, L ) | ( operation ) |

Here `K` is a semisimple subalgebra of the *simple* Lie algebra `L`. This function returns a list of integers, containing the Dynkin indices of the simple components of `K`. If the input Lie algebra `L` is not simple, then still a list of rationals is returned, but they may have no meaning. The Dynkin index is defined as follows. Consider a simple component in `K` and let h be the coroot of the shortest root of `K`. Let k denote the Killing form of `L`, normalised so that the coroot of the shortest root of `L` has squared length 2. Then the Dynkin index is k(h,h)/2.

gap> s:= LieAlgebraAndSubalgebras( "C7" );; gap> g:= InclusionsGraph( "C7" );; gap> m:= Filtered( g, x -> x[1]=0 );; i:= List( m, x -> x[2] ); [ 63, 498, 665, 804, 819, 821, 822 ] gap> L:= s.liealg; <Lie algebra of dimension 105 over Rationals> gap> sub:= s.subalgs;; gap> List( sub{i}, SemiSimpleType ); [ "A1", "C3", "A1 B3", "A6", "C3 C4", "B2 C5", "A1 C6" ] gap> DynkinIndex( sub[665], L ); [ 7, 4 ]

`‣ AreLinearlyEquivalentSubalgebras` ( L, K1, K2 ) | ( operation ) |

Here `L` is a semisimple Lie algebra, and `K1`, `K2` are subalgebras. It is assumed that the Cartan subalgebras (as returned by `CartanSubalgebra`) of `K1`, `K2` are contained in the Cartan subalgebra of `L` (otherwise `fail` is returned). This function returns `true` if `K1`, `K2` are linearly equivalent, `false ` otherwise.

# Lets find the subalgebras in the database for C5 that are linearly # equivalent to regular subalgebras: gap> s:= LieAlgebraAndSubalgebras("C5");; L:= s.liealg; sub:= s.subalgs;; <Lie algebra of dimension 55 over Rationals> gap> reg:= RegularSemisimpleSubalgebras( L );; gap> posn:= [];; gap> for K in reg do > Add(posn,PositionProperty(sub,M -> AreLinearlyEquivalentSubalgebras(L,M,K))); > od; gap> posn; [ 2, 24, 93, 111, 105, 82, 106, 81, 41, 109, 70, 85, 29, 112, 94, 25, 1, 118, 100, 102, 64, 108, 84, 28, 117, 107, 116, 96, 101, 63, 115, 114, 95, 113 ]

`‣ MakeDatabaseEntry` ( r ) | ( operation ) |

`‣ AddToDatabase` ( d ) | ( operation ) |

These are functions that help to save a computed list of subalgebras of a semisimple Lie algebra in a file, and in a new session, read it again. In the first function `r` is a record as produced by `LieAlgebraAndSubalgebras`

(5.2-3). It returns a record that can be saved in a file. (It is not advisable to print it on the screen.) In the second function `d` is a record that is output by `MakeDatabaseEntry`

. This function adds this entry to the database.

We give two examples; in the first one we create a new database entry, and save it to a file. In the second example we read it and add it to the database.

gap> r:= LieAlgebraAndSubalgebras( "A2 B2" );; gap> d:= MakeDatabaseEntry( r );; gap> PrintTo( "A2B2", "d:= ",d,";\n");

gap> Read("A2B2"); gap> AddToDatabase( d ); gap> SSSTypes(); [ "A1", "A2", "B2", "G2", "A3", "B3", "C3", "A4", "B4", "C4", "D4", "F4", "A5", "B5", "C5", "D5", "A6", "B6", "C6", "D6", "E6", "A7", "B7", "C7", "D7", "E7", "A8", "B8", "C8", "D8", "E8", "A2 B2" ]

`‣ ClosedSubsets` ( R ) | ( operation ) |

Here `R` is a root system. A subset S of the roots of `R` is said to be closed if for all a,b∈ S we have that a+b lies in S whenever a+b is a root. This function computes the list of the closed subsets of `R` up to conjugacy by the Weyl group. In other words, each closed subset of `R` is conjugate under the Weyl group to exactly one element of the output of this function. The output is a list of which each element is a list of roots. A root in such a list, or its negative, lies in the attribute `PositiveRootsNF( R )`.

gap> R:= RootSystem("F",4); <root system of type F4> gap> c:= ClosedSubsets(R);; gap> Length(c); 4844 gap> c[1005]; [ [ 1, 1, 0, 0 ], [ 0, 0, 1, 1 ], [ 0, 1, 2, 0 ], [ 0, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 2, 2, 0 ], [ 1, 1, 2, 1 ], [ 0, 1, 2, 2 ], [ 1, 1, 2, 2 ], [ 1, 2, 3, 1 ], [ 1, 2, 2, 2 ], [ 1, 2, 3, 2 ], [ 1, 2, 4, 2 ], [ 1, 3, 4, 2 ], [ 2, 3, 4, 2 ], [ 0, -1, -2, 0 ] ]

`‣ DecompositionOfClosedSet` ( c ) | ( operation ) |

Here `c` is a closed set of roots of some root system. We have that `c` is the disjoint union of its symmetric part (consisting of all roots a in `c` such that -a also lies in `c`) and its special part (consisting of all roots a in `c` such that -a does not lie in `c`). This function returns a list of two entries. The first is the symmetric part of `c`, the second is the special part of `c`.

gap> R:= RootSystem("F",4); <root system of type F4> gap> c:= ClosedSubsets(R);; gap> DecompositionOfClosedSet( c[1005] ); [ [ [ 0, 1, 2, 0 ], [ 0, -1, -2, 0 ] ], [ [ 1, 1, 0, 0 ], [ 0, 0, 1, 1 ], [ 0, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 2, 2, 0 ], [ 1, 1, 2, 1 ], [ 0, 1, 2, 2 ], [ 1, 1, 2, 2 ], [ 1, 2, 3, 1 ], [ 1, 2, 2, 2 ], [ 1, 2, 3, 2 ], [ 1, 2, 4, 2 ], [ 1, 3, 4, 2 ], [ 2, 3, 4, 2 ] ] ]

`‣ IsSpecialClosedSet` ( c ) | ( operation ) |

Here `c` is a closed set of roots of some root system. This function returns `true` is `c` is special (that is, for all a in `c` we have that -a does not lie in `c`), otherwise it returns `false`.

gap> R:= RootSystem("F",4); <root system of type F4> gap> c:= ClosedSubsets(R);; gap> IsSpecialClosedSet( c[1005] ); false gap> IsSpecialClosedSet( c[1006] ); true gap> Length( Filtered( c, IsSpecialClosedSet ) ); 3579

`‣ LieAlgebraOfClosedSet` ( L, c ) | ( operation ) |

Here `L` is a semisimple Lie algebra and `c` is a closed set of roots of its root system. This function returns the subalgebra of `L` spanned a the Cartan subalgebra of `L` (the one relative to which the root system is taken) along with the root vectors corresponding to the roots in `c`.

gap> L:= SimpleLieAlgebra("F",4,Rationals); <Lie algebra of dimension 52 over Rationals> gap> R:= RootSystem( L ); <root system of rank 4> gap> c:= ClosedSubsets(R);; gap> c[1005]; [ [ 1, 0, 1, 0 ], [ 0, 1, 0, 1 ], [ 1, 0, 1, 1 ], [ 0, 0, 2, 1 ], [ 1, 1, 1, 1 ], [ 1, 1, 2, 1 ], [ 2, 0, 2, 1 ], [ 0, 1, 2, 2 ], [ 2, 1, 2, 1 ], [ 1, 1, 3, 2 ], [ 2, 1, 2, 2 ], [ 2, 1, 3, 2 ], [ 2, 1, 4, 2 ], [ 2, 1, 4, 3 ], [ 2, 2, 4, 3 ], [ 0, 0, -2, -1 ] ] gap> K:= SubalgebraOfClosedSet( L, c[1005] ); <Lie algebra of dimension 20 over Rationals> gap> LeviMalcevDecomposition(K); [ <Lie algebra of dimension 3 over Rationals>, <two-sided ideal in <Lie algebra of dimension 20 over Rationals>, (dimension 17)> ]

generated by GAPDoc2HTML