This chapter contains functions for creating and working with finite order automorphisms of simple Lie algebras (or, more precisely, representatives of the conjugacy classes of such automorphisms).

NB: such automorphisms are not created for a given Lie algebra, but the Lie algebra is constructed at the same time as the automorphism. This because the base field may need extending (it needs enough roots of unity).

As noted above the functions give representatives of the conjugacy classes, in the automorphism group of the underlying Lie algebra, of finite order automorphisms. Such conjugacy classes are classified in terms of Kac diagrams. Roughly, this works as follows. A finite order automorphism f corresponds to a diagram automorphism of order d=1,2,3. The inner automorphisms correspond to a diagram automorphism of order 1, the outer automorphisms to a diagram automorphism of order 2 or 3. Let L_0, L_1 denote the eigenspaces of the underlying Lie algebra L, with respect to the diagram automorphism, respectively corresponding to the eigenvalues 1 and w (where w is a primitive d-th root of unity). (In case of d=1, we have L_0=L, L_1=0.) Then L_0 is semisimple and we choose a set of canonical generators of L_0, denoted x_i, y_i, h_i, for i=1,...,s. Moreover, L_1 is an L_0-module. Let x_0 be the lowest weight vector in L_1. (If d=1 then x_0 will be the lowest (negative) root vector.) Let α_i for i=0,...,s be the roots corresponding to x_i, with respect to the subalgebra spanned by the h_i. Let C be the Cartan matrix of these roots. The rows of C are linearly dependent. The Dynkin diagram of C is labeled with integers a_i with greatest common divisor 1, that form the coefficients of a linear dependency of the rows of C. Furthermore, the x_i generate L and the automorphism f is described by f(x_i) = v^s_i x_i, where the non-negative integers s_i have greatest common divisor 1, and are such that m=d∑ a_i s_i is the order of f, and where v is a primitive m-th order root of unity. Now the Kac diagram of the automorphism f is the Dynkin diagram of C, labelled with the labels s_i.

`‣ FiniteOrderInnerAutomorphisms` ( type, rank, m ) | ( operation ) |

Let L be the simple Lie algebra of type `type` and rank `rank`. The function returns representatives of the conjugacy classes of inner automorphisms of L of order `m`. As noted also in the introduction to this chapter, this function constructs the Lie algebra as well as the automorphisms (and the Lie algebra is accessible through the source of these automorphisms). The reason for this is that depending on the order of the automorphisms, the base field needs certain roots of unity.

gap> f:= FiniteOrderInnerAutomorphisms("E",6,3); [ [ v.72, v.1, v.2, v.3, v.4, v.5, v.6 ] -> [ (E(3))*v.72, (E(3)^2)*v.1, v.2, v.3, v.4, v.5, v.6 ], [ v.72, v.1, v.2, v.3, v.4, v.5, v.6 ] -> [ v.72, (E(3))*v.1, (E(3))*v.2, v.3, v.4, v.5, v.6 ], [ v.72, v.1, v.2, v.3, v.4, v.5, v.6 ] -> [ (E(3))*v.72, v.1, (E(3))*v.2, v.3, v.4, v.5, v.6 ], [ v.72, v.1, v.2, v.3, v.4, v.5, v.6 ] -> [ v.72, v.1, v.2, v.3, (E(3))*v.4, v.5, v.6 ], [ v.72, v.1, v.2, v.3, v.4, v.5, v.6 ] -> [ (E(3))*v.72, (E(3))*v.1, v.2, v.3, v.4, v.5, (E(3))*v.6 ] ] gap> Source(f[1]); <Lie algebra of dimension 78 over CF(3)>

`‣ FiniteOrderOuterAutomorphisms` ( type, rank, m, d ) | ( operation ) |

Let L be the simple Lie algebra of type `type` and rank `rank`. The function returns representatives of the conjugacy classes of outer automorphisms of L of order `m`, corresponding to a diagram automorphism of order `d`.

`‣ Order` ( f ) | ( attribute ) |

Here `f` is a finite order automorphism. This returns its order.

`‣ KacDiagram` ( f ) | ( attribute ) |

Here `f` is a finite order automorphism. This returns its Kac diagram. This is a record with three components: `CM`, which is the Cartan matrix of the Dynkin diagram, `labels` the integers with gcd equal to 1 that are the coefficients of a linear dependency of the rows of `CM`, and `weights` that are the integers s_i that define the automorphism.

gap> f:= FiniteOrderOuterAutomorphisms( "A", 5, 4, 2 );; gap> r:= KacDiagram( f[1] ); rec( CM := [ [ 2, 0, -1, 0 ], [ 0, 2, -1, 0 ], [ -1, -1, 2, -1 ], [ 0, 0, -2, 2 ] ], labels := [ 1, 1, 2, 1 ], weights := [ 1, 1, 0, 0 ] ) gap> r.labels*r.CM; [ 0, 0, 0, 0 ]

`‣ Grading` ( f ) | ( attribute ) |

Here `f` is a finite order automorphism of order m. This returns a list of length m. The i-th element contains a basis of the eigenspace of `f` with eigenvalue v^i, where v is a primitive m-th root of unity (i.e., `v=E(m)`).

`‣ NilpotentOrbitsOfThetaRepresentation` ( f ) | ( operation ) |

`‣ NilpotentOrbitsOfThetaRepresentation` ( L, d ) | ( operation ) |

Here `f` is an automorphism of a simple Lie algebra L of order m. Then `f` defines a grading on L. Let the homogeneous components of this grading be denoted L_i for i=0,...,m-1. Let G_0 be the group corresponding to L_0 (i.e., the connected subgroup of the adjoint group of L with Lie algebra L_0). This function computes representatives for the nilpotent orbits of G_0 acting on L_1. The output is a list of triples. Each triple is an sl_2-triple (y,h,x), with h∈ L_0, x∈ L_1 (the representative of the orbit), and y∈ L_m-1. The element h also lies in the dominant Weyl chamber of a Cartan subalgebra of L_0. Finally we note that all elements lie in `Source( f )`.

It is possible to add an extra optional argument: `method:= "Carrier"`, or `method:= "WeylOrbit"`. Then a method based on finding carrier algebras (respectively, computing orbits under the Weyl group) is chosen. If no optional argument is chosen, then the system will make its own choice. (In the case of outer automorphisms, currently the only available method is the one based on orbits of the Weyl group.) The method based on carrier algebras tends to work better for the higher order automorphisms.

This function prints some information on what it is doing to the info class `InfoSLA`. In order to suppress these messages one can do `SetInfoLevel( InfoSLA, 1 );`.

In the two-argument version, the first argument `L` has to be a semisimple Lie algebra, and the second argument `d` a list of non-negative integers. Then `L` is Z-graded by giving the root space corresponding to the i-th simple root the degree `d[i]`. Apart from this the function works the same in this case as in the one-argument version.

gap> f:= FiniteOrderInnerAutomorphisms( "D", 5, 3 );; gap> s:= NilpotentOrbitsOfThetaRepresentation( f[2] : method:= "Carrier" );; time; #I Selected carrier algebra method. #I Constructed 123 root bases of possible flat subalgebras, now checking them... #I Obtained 30 Cartan elements, weeding out equivalent copies... 776 gap> Length(s); 10 gap> s[4]; [ v.14+v.15+v.38, (-2)*v.41+(-1)*v.42, v.18+v.34+v.35 ] gap> L:= SimpleLieAlgebra("E",6,Rationals);; gap> NilpotentOrbitsOfThetaRepresentation( L, [0,1,0,0,0,0] ); #I Selected Weyl orbit method. #I Constructed a Weyl transversal of 72 elements. #I Obtained 5 Cartan elements, weeding out equivalent copies... [ [ v.65+v.66+v.67, (2)*v.73+(3)*v.74+(4)*v.75+(6)*v.76+(4)*v.77+(2)*v.78, v.29+v.30+v.31 ], [ (2)*v.55+(2)*v.66, (2)*v.73+(4)*v.74+(4)*v.75+(6)*v.76+(4)*v.77+(2)*v.78, v.19+v.30 ], [ v.63+v.71, (2)*v.73+(2)*v.74+(3)*v.75+(4)*v.76+(3)*v.77+(2)*v.78, v.27+v.35 ], [ v.71, v.73+v.74+(2)*v.75+(3)*v.76+(2)*v.77+v.78, v.35 ] ]

`‣ ClosureDiagram` ( L, f, s ) | ( operation ) |

`‣ ClosureDiagram` ( L, d, s ) | ( operation ) |

Here `f` is an automorphism of a simple Lie algebra L of order m, and `s` a list of sl_2-triples (y,h,x), with h∈ L_0, x∈ L_1 (for instance as computed by the previous function), corresponding to nilpotent orbits in L_1.

This function computes the Hasse diagram of the closures of the nilpotent orbits. The output is a record with two components: `diag` (which is a list of 2-tuples; a tuple `[ i, j ]` means that orbit number `i` is contained in the closure of orbit number `j`), and `sl2` (the same list of sl_2-triples, but sorted according to decreasing dimension, i.e., the highest dimensional orbit comes first). The numbering used in the tuples in `diag` corresponds to the order in which the orbits appear in the component `sl2`.

During the execution of the program a message is printed. This message either states that all inclusions have been proved, or lists a number of possible inclusions, for which it could not be proved with absolute certainty that these do not occur. This is due to the randomised nature of the algorithm: if the algorithm finds an inclusion, then this inclusion is certain. However, sometimes a non-inclusion can only be estabished by random methods, which means that it is possible that there is an inclusion without the program finding it. (This however, is very unlikely, and in practice almost never happens.) Now showing that a non-inclusion really is a non-inclusion can be done by computing the ranks of certain matrices with polynomial entries. In principle **GAP** can do this; however, the system certainly is not very strong at it. Therefore, as optional argument a filename can be given, by `filenm:= "file.m"`. If this argument is present the program prints a Magma script in the file, which can be loaded directly into the computer algebra system Magma. If the output is always true, then all non-inclusions are proved. If there are non non-inclusions to be proved, then the file is not written.

In the second version, the second argument `d` is a list of non-negative integers. Then `L` is Z-graded by giving the root space corresponding to the i-th simple root the degree `d[i]`. Apart from this the function works in the same way.

We note that the adjoint representation can be obtained by giving a `d` that eintirely consists of zeros.

gap> f:= FiniteOrderInnerAutomorphisms( "E", 8, 8 );; gap> h:= f[8];; gap> sl2:= NilpotentOrbitsOfThetaRepresentation(h);; #I Selected carrier algebra method. #I Constructed 2782 root bases of possible flat subalgebras, now checking them... #I Obtained 58 Cartan elements, weeding out equivalent copies... gap> time; 117792 gap> Length(sl2); 27 gap> L:= Source(h);; gap> r:= ClosureDiagram( L, h, sl2 );; #I All (non-) inclusions proved! gap> time; 329248 gap> r.diag; [ [ 2, 1 ], [ 3, 1 ], [ 4, 2 ], [ 4, 3 ], [ 5, 1 ], [ 6, 5 ], [ 7, 2 ], [ 7, 5 ], [ 8, 4 ], [ 9, 3 ], [ 9, 6 ], [ 10, 6 ], [ 10, 7 ], [ 11, 4 ], [ 11, 7 ], [ 12, 7 ], [ 13, 9 ], [ 13, 10 ], [ 13, 11 ], [ 14, 11 ], [ 14, 12 ], [ 15, 6 ], [ 16, 8 ], [ 16, 11 ], [ 17, 13 ], [ 17, 16 ], [ 18, 13 ], [ 18, 15 ], [ 19, 10 ], [ 19, 12 ], [ 19, 15 ], [ 20, 14 ], [ 20, 16 ], [ 21, 9 ], [ 21, 15 ], [ 22, 14 ], [ 22, 18 ], [ 22, 19 ], [ 23, 18 ], [ 23, 21 ], [ 24, 17 ], [ 24, 18 ], [ 25, 20 ], [ 25, 22 ], [ 25, 24 ], [ 26, 22 ], [ 26, 23 ], [ 27, 23 ], [ 27, 24 ] ] # Now we do the adjoint representation of the Lie algebra of type F4: gap> L:= SimpleLieAlgebra("F",4,Rationals);; gap> o:= NilpotentOrbits(L);; gap> sl2:= List( o, SL2Triple );; gap> r:= ClosureDiagram( L, [0,0,0,0], sl2 );; #I All (non-) inclusions proved! gap> r.diag; [ [ 2, 1 ], [ 3, 2 ], [ 4, 3 ], [ 5, 3 ], [ 6, 5 ], [ 6, 4 ], [ 7, 6 ], [ 8, 7 ], [ 9, 7 ], [ 10, 9 ], [ 10, 8 ], [ 11, 8 ], [ 12, 10 ], [ 13, 12 ], [ 13, 11 ], [ 14, 13 ], [ 15, 14 ] ]

`‣ CarrierAlgebra` ( L, f, e ) | ( operation ) |

`‣ CarrierAlgebra` ( L, d, e ) | ( operation ) |

Here `f` is an automorphism of a simple Lie algebra L of order m, and `e` a nilpotent element of L_1. This function returns the carrier algebra of `e`. This is a Z-graded semisimple subalgebra K of L, such that `e` lies in K_1. For the precise definition we refer to [Vin79], [Vin75]. The output is given in the form of a record, with three components: `g0`, a basis of K_0, `gp` a list containing bases of K_1, K_2 and so on, and `gn` a list containing bases of K_-1, K_-2 and so on.

In the second version, the second argument `d` is a list of non-negative integers. Then `L` is Z-graded by giving the root space corresponding to the i-th simple root the degree `d[i]`. Apart from this the function works in the same way.

gap> f:= FiniteOrderInnerAutomorphisms( "F", 4, 5 );; gap> h:= f[4];; gap> sl2:= NilpotentOrbitsOfThetaRepresentation( h );; #I Selected Weyl orbit method. #I Constructed a Weyl transversal of 144 elements. #I Constructed 621 Cartan elements to be checked. gap> L:= Source(h); <Lie algebra of dimension 52 over CF(5)> gap> r:=CarrierAlgebra( L, h, sl2[1][3] ); rec( g0 := [ v.49+(2)*v.50+(2)*v.51+(3)*v.52, v.50+(1/2)*v.51+v.52 ], gp := [ [ v.9, v.48 ], [ v.45 ], [ v.39 ] ], gn := [ [ v.24, v.33 ], [ v.21 ], [ v.15 ] ] ) gap> K:= Subalgebra( L, Concatenation( r.g0, Flat(r.gp), Flat(r.gn) ) ); <Lie algebra over CF(5), with 10 generators> gap> SemiSimpleType( K ); "B2"

`‣ CartanSubspace` ( f ) | ( operation ) |

Here `f` is an automorphism of a simple Lie algebra L of order m. Then `f` defines a grading on L. Let the homogeneous components of this grading be denoted L_i for i=0,...,m-1. Let G_0 be the group corresponding to L_0 (i.e., the connected subgroup of the adjoint group of L with Lie algebra L_0). This function computes a maximal subspace of L_1 consisting of commuting semisimple elements. (Such a subspace is called a *Cartan subspace*.)

Every semisimple orbit of G_0 in L_1 contains an element of a fixed Cartan subspace.

gap> f:= FiniteOrderInnerAutomorphisms( "A", 3, 3 );; gap> c:= CartanSubspace( f[3] ); <vector space of dimension 1 over CF(3)> gap> BasisVectors( Basis( c ) ); [ v.1+v.5+v.12 ]

generated by GAPDoc2HTML