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

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.

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

`‣ 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 );; time; 1664 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 ] ] # there are the edges [ 14, 10] and [ 10, 2 ]; hence a conjugate of the # 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" ]

generated by GAPDoc2HTML