3 Real Lie Algebras

A few functions print some information on what they are doing to the info class `InfoCorelg`.

`‣ RealFormsInformation` ( type, rank ) | ( function ) |

This function displays information regarding the simple real Lie algebras that can be constructed from the complex Lie algebra of type `type` (which is a string) and rank `rank` (a positive integer). Each Lie algebra is given an index which is an integer, and for each index some information is given on the Lie algebra, such as a commonly used name. In all cases the index 0 refers to the realification of the complex Lie algebra.

gap> RealFormsInformation( "A", 4 ); There are 4 simple real forms with complexification A4 1 is of type su(5), compact form 2 - 3 are of type su(p,5-p) with 1 <= p <= 2 4 is of type sl(5,R) Index '0' returns the realification of A4 gap> RealFormsInformation( "E", 6 ); There are 5 simple real forms with complexification E6 1 is the compact form 2 is EI = E6(6), with k_0 of type sp(4) (C4) 3 is EII = E6(2), with k_0 of type su(6)+su(2) (A5+A1) 4 is EIII = E6(-14), with k_0 of type so(10)+R (D5+R) 5 is EIV = E6(-26), with k_0 of type f_4 (F4) Index '0' returns the realification of E6 gap> NumberRealForms("D",10); 12

`‣ NumberRealForms` ( type, rank ) | ( function ) |

This function returns the number of (isomorphism types of) all real forms of the simple complex Lie algebras of type `type` and rank `rank`.

`‣ RealFormById` ( type, rank, id ) | ( function ) |

`‣ RealFormById` ( type, rank, id, F ) | ( function ) |

Let L be the complex Lie algebra of type `type` and rank `rank`. This function constructs the real form of L with index `id` (see `RealFormsInformation`

(3.1-1)). By default this Lie algebra is constructed over the field `SqrtField`. However, by adding as an optional fourth argument the field `F`, it is possible to construct the Lie algebra output by this function over `F`. It is required that the complex unit `E(4)` is contained in `F`. If the index `ind` is 0, then the realification of L is constructed, which, strictly speaking is not a real form of L.

gap> RealFormById( "A", 4, 2 ); <Lie algebra of dimension 24 over SqrtField> gap> RealFormById( "A", 4, 2, CF(4) ); <Lie algebra of dimension 24 over GaussianRationals>

`‣ AllRealForms` ( type, rank ) | ( function ) |

This function returns all real forms of the simple complex Lie algebras of type `type` and rank `rank` up to isomorphism. In the same way as with `RealFormById`

(3.1-3) it is possible to add the base field as an optional third argument.

`‣ RealFormParameters` ( L ) | ( attribute ) |

For a real Lie algebra `L` constructed by the function `RealFormById`

(3.1-3), this function returns a list of the parameters defining `L` as a real form of its complexification. The first element of the list is the type of `L` (given by a string), the second element is its rank, the third and fourth elements are the list of signs and the permutation defining the Cartan involution (see Section 1.1).

`‣ IsRealFormOfInnerType` ( L ) | ( property ) |

Returns `true` if and only if the real form `L` is a defined by an inner involutive automorphism.

`‣ IsRealification` ( L ) | ( property ) |

Returns `true` if and only if the real form `L` is the realification of a complex simple Lie algebra.

`‣ CartanDecomposition` ( L ) | ( attribute ) |

The Cartan decomposition of `L` as a record with entries `K`, `P`, and `CartanInv`, such that L=K⊕ P is the Cartan decomposition with corresponding Cartan involution `CartanInv`, which is defined as a function on `L`.

The Lie algebras constructed by `RealFormById`

(3.1-3) have this attribute stored. For other semisimple real Lie algebras it is computed. However, we do remark that the in the computation the root system is computed with respect to a Cartan subalgebra. If the program does not succeed in splitting the Cartan subalgebra over the base field of `L`, then the computation will not succeed.

gap> L:= RealFormById( "A", 5, 3 ); <Lie algebra of dimension 35 over SqrtField> gap> H := CartanSubalgebra(L);; gap> K:= LieCentralizer( L, Subalgebra( L, [Basis( H )[1]] ) ); <Lie algebra of dimension 17 over SqrtField> gap> DK:= LieDerivedSubalgebra( K ); <Lie algebra of dimension 15 over SqrtField> gap> CartanDecomposition( DK ); rec( CartanInv := function( v ) ... end, K := <Lie algebra of dimension 15 over SqrtField>, P := <vector space over SqrtField, with 0 generators> ) # We see that the semisimple subalgebra DK is compact.

`‣ RealStructure` ( L ) | ( attribute ) |

`‣ RealStructure` ( L: basis := B ) | ( attribute ) |

The real structure of the real form `L` is the (complex) conjugation with respect to `L`, that is, the function which maps an element in `L` to the element constructed as follows: write it as a linear combination of the basis elements of `L` and replace each coefficient by its complex conjugate. If the optional argument `basis:=B` is given, then `B` has to be a basis whose span contains `L` (which is not checked by the code); in this case the linear combination is done with respect to `B`. The latter construction is important when one considers a subalgebra `M` of a real form `L`; here one could either do `Realstructure(M:basis:=Basis(L))` or `SetRealStructure(M,RealStructure(L))`.

`‣ IsomorphismOfRealSemisimpleLieAlgebras` ( K, L ) | ( function ) |

Here `K`, `L` are two real forms of a semisimple complex Lie algebra. This function returns an isomorphism if one exists. Otherwise `false` is returned.

gap> L:=RealFormById("E",6,3);; gap> H:=CartanSubalgebra(L);; gap> K:=LieCentralizer(L,Subalgebra(L,Basis(H){[1,2,4]}));; gap> DK:=LieDerivedSubalgebra(K); <Lie algebra of dimension 8 over SqrtField> gap> IdRealForm(DK); [ "A", 2, 2 ] gap> M:=RealFormById("A",2,2); <Lie algebra of dimension 8 over SqrtField> gap> IsomorphismOfRealSemisimpleLieAlgebras(DK,M); <Lie algebra isomorphism between Lie algebras of dimension 8 over SqrtField>

`‣ MaximallyCompactCartanSubalgebra` ( L ) | ( attribute ) |

Here `L` is a real semisimple Lie algebra. This function returns a maximally compact Cartan subalgebra of `L`.

`‣ MaximallyNonCompactCartanSubalgebra` ( L ) | ( attribute ) |

Here `L` is a real semisimple Lie algebra. This function returns a maximally non-compact Cartan subalgebra of `L`.

`‣ CompactDimensionOfCartanSubalgebra` ( L ) | ( function ) |

`‣ CompactDimensionOfCartanSubalgebra` ( L, H ) | ( function ) |

Here `L` is a real semisimple Lie algebra. This function returns the compact dimension of the Cartan subalgebra `H`. If `H` is not given, then `CartanSubalgebra(L)` will be taken. The compact dimension will be stored in the Cartan subalgebra, so that a new call to this function, with the same input, will return the compact dimension immediately.

`‣ CartanSubalgebrasOfRealForm` ( L ) | ( attribute ) |

Here `L` is a real form of a complex semisimple Lie algebra. This function returns a list of Cartan subalgebras of `L`. They are representatives of all classes of conjugate (by the adjoint group) Cartan subalgebras of `L`.

`‣ CartanSubspace` ( L ) | ( attribute ) |

Here `L` is a real semisimple Lie algebra. This function returns a Cartan subspace of `L`. That is a maximal abelian subspace of the subspace `P` given in the `CartanDecomposition`

(3.1-8) of `L`.

`‣ RootsystemOfCartanSubalgebra` ( L ) | ( operation ) |

`‣ RootsystemOfCartanSubalgebra` ( L, H ) | ( operation ) |

Here `L` is a semisimple Lie algebra, and `H` is a Cartan subalgebra. (If `H` is not given, then `CartanSubalgebra(L)` will be taken.) This function returns the root system of `L` with respect to `H`. It is necessary that the eigenvalues of the adjoint maps corresponding to all elements of `H` lie in the ground field of `L`. However, even if they do, it is not guaranteed that this function succeeds, as it may happen that **GAP** has no polynomial factorisation algorithm over the ground field.

The root system is stored in `H`, so that a new call to this function, with the same input, will return the same root system.

`‣ ChevalleyBasis` ( R ) | ( attribute ) |

Here `R` is a root system of a semisimple Lie algebra `L`. This function returns a Chevalley basis of `L`, consisting of root vectors of `R`.

In this section we document the functionality for computing the Satake and Vogan diagrams of a real semisimple Lie algebra. In both cases the relevant function computes an object, which, when printed, does not reveal much information. However, `Display` with as input such an object, displays the diagram. Here we use the convention that every node is represented by an integer; nodes that are painted black are represented by integers in brackets; and the involution (i.e., the arrows in the diagram) are represented by a permutation of the nodes, printed on a line below the diagram.

`‣ VoganDiagram` ( L ) | ( attribute ) |

Here `L` is a real semisimple Lie algebra. This function returns the Vogan diagram of `L`.

gap> L:= RealFormById( "E", 6, 3 );; gap> K:= LieCentralizer( L, Subalgebra( L, Basis( CartanSubalgebra(L) ){[1]} ) ); <Lie algebra of dimension 36 over SqrtField> gap> DK:= LieDerivedSubalgebra( K ); <Lie algebra of dimension 35 over SqrtField> gap> vd:= VoganDiagram(DK); <Vogan diagram in Lie algebra of type A5> gap> Display( vd ); A5: 1---(2)---3---4---5 Involution: ()

`‣ SatakeDiagram` ( L ) | ( attribute ) |

Here `L` is a real semisimple Lie algebra. This function returns the Satake diagram of `L`.

gap> L:= RealFormById( "E", 6, 3 );; gap> K:= LieCentralizer( L, Subalgebra( L, Basis( CartanSubalgebra(L) ){[1]} ) ); <Lie algebra of dimension 36 over SqrtField> gap> DK:= LieDerivedSubalgebra( K ); <Lie algebra of dimension 35 over SqrtField> gap> sd:= SatakeDiagram( DK ); <Satake diagram in Lie algebra of type A5> gap> Display( sd ); A5: 1---2---(3)---4---5 Involution: (1,5)(2,4)

generated by GAPDoc2HTML