A Lie algebra \(L\) is an algebra such that \(x x = 0\) and \(x(yz) + y(zx) + z(xy) = 0\) for all \(x, y, z \in L\). A common way of creating a Lie algebra is by taking an associative algebra together with the commutator as product. Therefore the product of two elements \(x, y\) of a Lie algebra is usually denoted by \([x,y]\), but in GAP this denotes the list of the elements \(x\) and \(y\); hence the product of elements is made by the usual *. This gives no problems when dealing with Lie algebras given by a table of structure constants. However, for matrix Lie algebras the situation is not so easy as * denotes the ordinary (associative) matrix multiplication. In GAP this problem is solved by wrapping elements of a matrix Lie algebra up as LieObjects, and then define the * for LieObjects to be the commutator (see 64.1).
Let x be a ring element, then LieObject(x) (see LieObject (64.1-1)) wraps x up into an object that contains the same data (namely x). The multiplication * for Lie objects is formed by taking the commutator. More exactly, if l1 and l2 are the Lie objects corresponding to the ring elements r1 and r2, then l1 * l2 is equal to the Lie object corresponding to r1 * r2 - r2 * r1. Two rules for Lie objects are worth noting:
An element is not equal to its Lie element.
If we take the Lie object of an ordinary (associative) matrix then this is again a matrix; it is therefore a collection (of its rows) and a list. But it is not a collection of collections of its entries, and its family is not a collections family.
Given a family F of ring elements, we can form its Lie family L. The elements of F and L are in bijection, only the multiplications via * differ for both families. More exactly, if l1 and l2 are the Lie elements corresponding to the elements f1 and f2 in F, we have l1 * l2 equal to the Lie element corresponding to f1 * f2 - f2 * f1. Furthermore, the product of Lie elements l1, l2 and l3 is left-normed, that is l1*l2*l3 is equal to (l1*l2)*l3.
The main reason to distinguish elements and Lie elements on the family level is that this helps to avoid forming domains that contain elements of both types. For example, if we could form vector spaces of matrices then at first glance it would be no problem to have both ordinary and Lie matrices in it, but as soon as we find out that the space is in fact an algebra (e.g., because its dimension is that of the full matrix algebra), we would run into strange problems.
Note that the family situation with Lie families may be not familiar.
We have to be careful when installing methods for certain types of domains that may involve Lie elements. For example, the zero element of a matrix space is either an ordinary matrix or its Lie element, depending on the space. So either the method must be aware of both cases, or the method selection must distinguish the two cases. In the latter situation, only one method may be applicable to each case; this means that it is not sufficient to treat the Lie case with the additional requirement IsLieObjectCollection but that we must explicitly require non-Lie elements for the non-Lie case.
Being a full matrix space is a property that may hold for a space of ordinary matrices or a space of Lie matrices. So methods for full matrix spaces must also be aware of Lie matrices.
‣ LieObject( obj ) | ( attribute ) |
Let obj be a ring element. Then LieObject( obj ) is the corresponding Lie object. If obj lies in the family F, then LieObject( obj ) lies in the family LieFamily( F ) (see LieFamily (64.1-3)).
gap> m:= [ [ 1, 0 ], [ 0, 1 ] ];; gap> lo:= LieObject( m ); LieObject( [ [ 1, 0 ], [ 0, 1 ] ] ) gap> m*m; [ [ 1, 0 ], [ 0, 1 ] ] gap> lo*lo; LieObject( [ [ 0, 0 ], [ 0, 0 ] ] )
‣ IsLieObject( obj ) | ( category ) |
‣ IsLieObjectCollection( obj ) | ( category ) |
‣ IsRestrictedLieObject( obj ) | ( category ) |
‣ IsRestrictedLieObjectCollection( obj ) | ( category ) |
An object lies in IsLieObject if and only if it lies in a family constructed by LieFamily (64.1-3).
gap> m:= [ [ 1, 0 ], [ 0, 1 ] ];; gap> lo:= LieObject( m ); LieObject( [ [ 1, 0 ], [ 0, 1 ] ] ) gap> IsLieObject( m ); false gap> IsLieObject( lo ); true
‣ LieFamily( Fam ) | ( attribute ) |
is a family F in bijection with the family Fam, but with the Lie bracket as infix multiplication. That is, for x, y in Fam, the product of the images in F will be the image of x * y - y * x.
The standard type of objects in a Lie family F is F!.packedType.
The bijection from Fam to F is given by Embedding( Fam, F ) (see Embedding (32.2-11)); this bijection respects addition and additive inverses.
‣ UnderlyingFamily( Fam ) | ( attribute ) |
If Fam is a Lie family then UnderlyingFamily( Fam ) is a family F such that Fam = LieFamily( F ).
‣ UnderlyingRingElement( obj ) | ( attribute ) |
Let obj be a Lie object constructed from a ring element r by calling LieObject( r ). Then UnderlyingRingElement( obj ) returns the ring element r used to construct obj. If r lies in the family F, then obj lies in the family LieFamily( F ) (see LieFamily (64.1-3)).
gap> lo:= LieObject( [ [ 1, 0 ], [ 0, 1 ] ] ); LieObject( [ [ 1, 0 ], [ 0, 1 ] ] ) gap> m:=UnderlyingRingElement(lo); [ [ 1, 0 ], [ 0, 1 ] ] gap> lo*lo; LieObject( [ [ 0, 0 ], [ 0, 0 ] ] ) gap> m*m; [ [ 1, 0 ], [ 0, 1 ] ]
In this section we describe functions that create Lie algebras. Creating and working with subalgebras goes exactly in the same way as for general algebras; so for that we refer to Chapter 62.
‣ LieAlgebraByStructureConstants( R, sct[, nameinfo] ) | ( function ) |
LieAlgebraByStructureConstants does the same as AlgebraByStructureConstants (62.4-1), and has the same meaning of arguments, except that the result is assumed to be a Lie algebra. Note that the function does not check whether sct satisfies the Jacobi identity. (So if one creates a Lie algebra this way with a table that does not satisfy the Jacobi identity, errors may occur later on.)
gap> T:= EmptySCTable( 2, 0, "antisymmetric" );; gap> SetEntrySCTable( T, 1, 2, [ 1/2, 1 ] ); gap> L:= LieAlgebraByStructureConstants( Rationals, T ); <Lie algebra of dimension 2 over Rationals>
‣ RestrictedLieAlgebraByStructureConstants( R, sct[, nameinfo], pmapping ) | ( function ) |
RestrictedLieAlgebraByStructureConstants does the same as LieAlgebraByStructureConstants (64.2-1), and has the same meaning of all arguments, except that the result is assumed to be a restricted Lie algebra (see 64.8) with the \(p\)-map given by the additional argument pmapping. This last argument is a list of the length equal to the dimension of the algebra; its \(i\)-th entry specifies the \(p\)-th power of the \(i\)-th basis vector in the same format [ coeff1, position1, coeff2, position2, ... ] as SetEntrySCTable (62.4-5) uses to specify entries of the structure constants table.
Note that the function does not check whether sct satisfies the Jacobi identity, of whether pmapping specifies a legitimate \(p\)-mapping.
The following example creates a commutative restricted Lie algebra of dimension 3, in which the \(p\)-th power of the \(i\)-th basis element is the \(i+1\)-th basis element (except for the 3rd basis element which goes to zero).
gap> T:= EmptySCTable( 3, Zero(GF(5)), "antisymmetric" );; gap> L:= RestrictedLieAlgebraByStructureConstants( > GF(5), T, [[1,2],[1,3],[]] ); <Lie algebra of dimension 3 over GF(5)> gap> List(Basis(L),PthPowerImage); [ v.2, v.3, 0*v.1 ] gap> PthPowerImage(L.1+L.2); v.2+v.3
‣ LieAlgebra( L ) | ( function ) |
‣ LieAlgebra( F, gens[, zero][, "basis"] ) | ( function ) |
For an associative algebra L, LieAlgebra( L ) is the Lie algebra isomorphic to L as a vector space but with the Lie bracket as product.
LieAlgebra( F, gens ) is the Lie algebra over the division ring F, generated as Lie algebra by the Lie objects corresponding to the vectors in the list gens.
Note that the algebra returned by LieAlgebra does not contain the vectors in gens. The elements in gens are wrapped up as Lie objects (see 64.1). This allows one to create Lie algebras from ring elements with respect to the Lie bracket as product. But of course the product in the Lie algebra is the usual *.
If there are three arguments, a division ring F and a list gens and an element zero, then LieAlgebra( F, gens, zero ) is the corresponding F-Lie algebra with zero element the Lie object corresponding to zero.
If the last argument is the string "basis" then the vectors in gens are known to form a basis of the algebra (as an F-vector space).
Note that even if each element in gens is already a Lie element, i.e., is of the form LieElement( elm ) for an object elm, the elements of the result lie in the Lie family of the family that contains gens as a subset.
gap> A:= FullMatrixAlgebra( GF( 7 ), 4 );; gap> L:= LieAlgebra( A ); <Lie algebra of dimension 16 over GF(7)> gap> mats:= [ [ [ 1, 0 ], [ 0, -1 ] ], [ [ 0, 1 ], [ 0, 0 ] ], > [ [ 0, 0 ], [ 1, 0] ] ];; gap> L:= LieAlgebra( Rationals, mats ); <Lie algebra over Rationals, with 3 generators>
‣ FreeLieAlgebra( R, rank[, name] ) | ( function ) |
‣ FreeLieAlgebra( R, name1, name2, ... ) | ( function ) |
Returns a free Lie algebra of rank rank over the ring R. FreeLieAlgebra( R, name1, name2,...) returns a free Lie algebra over R with generators named name1, name2, and so on. The elements of a free Lie algebra are written on the Hall-Lyndon basis.
gap> L:= FreeLieAlgebra( Rationals, "x", "y", "z" ); <Lie algebra over Rationals, with 3 generators> gap> g:= GeneratorsOfAlgebra( L );; x:= g[1];; y:=g[2];; z:= g[3];; gap> z*(y*(x*(z*y))); (-1)*((x*(y*z))*(y*z))+(-1)*((x*((y*z)*z))*y)+(-1)*(((x*z)*(y*z))*y)
‣ FullMatrixLieAlgebra( R, n ) | ( function ) |
‣ MatrixLieAlgebra( R, n ) | ( function ) |
‣ MatLieAlgebra( R, n ) | ( function ) |
is the full matrix Lie algebra of \(\textit{n} \times \textit{n}\) matrices over the ring R, for a nonnegative integer n.
gap> FullMatrixLieAlgebra( GF(9), 10 ); <Lie algebra over GF(3^2), with 19 generators>
‣ RightDerivations( B ) | ( attribute ) |
‣ LeftDerivations( B ) | ( attribute ) |
‣ Derivations( B ) | ( attribute ) |
These functions all return the matrix Lie algebra of derivations of the algebra \(A\) with basis B.
RightDerivations( B ) returns the algebra of derivations represented by their right action on the algebra \(A\). This means that with respect to the basis \(B\) of \(A\), the derivation \(D\) is described by the matrix \([ d_{{i,j}} ]\) which means that \(D\) maps the \(i\)-th basis element \(b_i\) to \(\sum_{{j = 1}}^n d_{{i,j}} b_j\).
LeftDerivations( B ) returns the Lie algebra of derivations represented by their left action on the algebra \(A\). So the matrices contained in the algebra output by LeftDerivations( B ) are the transposes of the matrices contained in the output of RightDerivations( B ).
Derivations is just a synonym for RightDerivations.
gap> A:= OctaveAlgebra( Rationals ); <algebra of dimension 8 over Rationals> gap> L:= Derivations( Basis( A ) ); <Lie algebra of dimension 14 over Rationals>
‣ SimpleLieAlgebra( type, n, F ) | ( function ) |
This function constructs the simple Lie algebra of type given by the string type and rank n over the field F. The string type must be one of "A", "B", "C", "D", "E", "F", "G", "H", "K", "S", "W" or "M". For the types A to G, n must be a positive integer. The last five types only exist over fields of characteristic \(p>0\). If the type is H, then n must be a list of positive integers of even length. If the type is K, then n must be a list of positive integers of odd length. For the types S and W, n must be a list of positive integers of any length. If the type is M, then the Melikyan algebra is constructed. In this case n must be a list of two positive integers. This Lie algebra only exists over fields of characteristic \(5\). This Lie algebra is \(ℤ \times ℤ\) graded; and the grading can be accessed via the attribute Grading(L) (see Grading (62.9-20)). In some cases the Lie algebra returned by this function is not simple. Examples are the Lie algebras of type \(A_n\) over a field of characteristic \(p>0\) where \(p\) divides \(n+1\), and the Lie algebras of type \(K_n\) where \(n\) is a list of length 1.
If type is one of A, B, C, D, E, F, G, and F is a field of characteristic zero, then the basis of the returned Lie algebra is a Chevalley basis.
gap> SimpleLieAlgebra( "E", 6, Rationals ); <Lie algebra of dimension 78 over Rationals> gap> SimpleLieAlgebra( "A", 6, GF(5) ); <Lie algebra of dimension 48 over GF(5)> gap> SimpleLieAlgebra( "W", [1,2], GF(5) ); <Lie algebra of dimension 250 over GF(5)> gap> SimpleLieAlgebra( "H", [1,2], GF(5) ); <Lie algebra of dimension 123 over GF(5)> gap> L:= SimpleLieAlgebra( "M", [1,1], GF(5) ); <Lie algebra of dimension 125 over GF(5)>
Here we describe functions that calculate well-known subalgebras and ideals of a Lie algebra (such as the centre, the centralizer of a subalgebra, etc.).
‣ LieCentre( L ) | ( attribute ) |
‣ LieCenter( L ) | ( attribute ) |
The Lie centre of the Lie algebra L is the kernel of the adjoint mapping, that is, the set \(\{ a \in L : \forall x \in L: a x = 0 \}\).
In characteristic \(2\) this may differ from the usual centre (that is the set of all \(a \in L\) such that \(a x = x a\) for all \(x \in L\)). Therefore, this operation is named LieCentre and not Centre (35.4-5).
gap> L:= FullMatrixLieAlgebra( GF(3), 3 ); <Lie algebra over GF(3), with 5 generators> gap> LieCentre( L ); <two-sided ideal in <Lie algebra of dimension 9 over GF(3)>, (dimension 1)>
‣ LieCentralizer( L, S ) | ( operation ) |
is the annihilator of S in the Lie algebra L, that is, the set \(\{ a \in L : \forall s \in S: a*s = 0 \}\). Here S may be a subspace or a subalgebra of L.
gap> L:= SimpleLieAlgebra( "G", 2, Rationals ); <Lie algebra of dimension 14 over Rationals> gap> b:= BasisVectors( Basis( L ) );; gap> LieCentralizer( L, Subalgebra( L, [ b[1], b[2] ] ) ); <Lie algebra of dimension 1 over Rationals>
‣ LieNormalizer( L, U ) | ( operation ) |
is the normalizer of the subspace U in the Lie algebra L, that is, the set \(N_L(U) = \{ x \in L : [x,U] \subset U \}\).
gap> L:= SimpleLieAlgebra( "G", 2, Rationals ); <Lie algebra of dimension 14 over Rationals> gap> b:= BasisVectors( Basis( L ) );; gap> LieNormalizer( L, Subalgebra( L, [ b[1], b[2] ] ) ); <Lie algebra of dimension 8 over Rationals>
‣ LieDerivedSubalgebra( L ) | ( attribute ) |
is the (Lie) derived subalgebra of the Lie algebra L.
gap> L:= FullMatrixLieAlgebra( GF( 3 ), 3 ); <Lie algebra over GF(3), with 5 generators> gap> LieDerivedSubalgebra( L ); <Lie algebra of dimension 8 over GF(3)>
‣ LieNilRadical( L ) | ( attribute ) |
This function calculates the (Lie) nil radical of the Lie algebra L.
gap> mats:= [ [[1,0],[0,0]], [[0,1],[0,0]], [[0,0],[0,1]] ];; gap> L:= LieAlgebra( Rationals, mats );; gap> LieNilRadical( L ); <two-sided ideal in <Lie algebra of dimension 3 over Rationals>, (dimension 2)>
‣ LieSolvableRadical( L ) | ( attribute ) |
Returns the (Lie) solvable radical of the Lie algebra L.
gap> L:= FullMatrixLieAlgebra( Rationals, 3 );; gap> LieSolvableRadical( L ); <two-sided ideal in <Lie algebra of dimension 9 over Rationals>, (dimension 1)>
‣ CartanSubalgebra( L ) | ( attribute ) |
A Cartan subalgebra of a Lie algebra L is defined as a nilpotent subalgebra of L equal to its own Lie normalizer in L.
gap> L:= SimpleLieAlgebra( "G", 2, Rationals );; gap> CartanSubalgebra( L ); <Lie algebra of dimension 2 over Rationals>
‣ LieDerivedSeries( L ) | ( attribute ) |
is the (Lie) derived series of the Lie algebra L.
gap> mats:= [ [[1,0],[0,0]], [[0,1],[0,0]], [[0,0],[0,1]] ];; gap> L:= LieAlgebra( Rationals, mats );; gap> LieDerivedSeries( L ); [ <Lie algebra of dimension 3 over Rationals>, <Lie algebra of dimension 1 over Rationals>, <Lie algebra of dimension 0 over Rationals> ]
‣ LieLowerCentralSeries( L ) | ( attribute ) |
is the (Lie) lower central series of the Lie algebra L.
gap> mats:= [ [[ 1, 0 ], [ 0, 0 ]], [[0,1],[0,0]], [[0,0],[0,1]] ];; gap> L:=LieAlgebra( Rationals, mats );; gap> LieLowerCentralSeries( L ); [ <Lie algebra of dimension 3 over Rationals>, <Lie algebra of dimension 1 over Rationals> ]
‣ LieUpperCentralSeries( L ) | ( attribute ) |
is the (Lie) upper central series of the Lie algebra L.
gap> mats:= [ [[ 1, 0 ], [ 0, 0 ]], [[0,1],[0,0]], [[0,0],[0,1]] ];; gap> L:=LieAlgebra( Rationals, mats );; gap> LieUpperCentralSeries( L ); [ <two-sided ideal in <Lie algebra of dimension 3 over Rationals>, (dimension 1)>, <Lie algebra of dimension 0 over Rationals> ]
‣ IsLieAbelian( L ) | ( property ) |
returns true if L is a Lie algebra such that each product of elements in L is zero, and false otherwise.
gap> T:= EmptySCTable( 5, 0, "antisymmetric" );; gap> L:= LieAlgebraByStructureConstants( Rationals, T ); <Lie algebra of dimension 5 over Rationals> gap> IsLieAbelian( L ); true
‣ IsLieNilpotent( L ) | ( property ) |
A Lie algebra L is defined to be (Lie) nilpotent when its (Lie) lower central series reaches the trivial subalgebra.
gap> T:= EmptySCTable( 5, 0, "antisymmetric" );; gap> L:= LieAlgebraByStructureConstants( Rationals, T ); <Lie algebra of dimension 5 over Rationals> gap> IsLieNilpotent( L ); true
‣ IsLieSolvable( L ) | ( property ) |
A Lie algebra L is defined to be (Lie) solvable when its (Lie) derived series reaches the trivial subalgebra.
gap> T:= EmptySCTable( 5, 0, "antisymmetric" );; gap> L:= LieAlgebraByStructureConstants( Rationals, T ); <Lie algebra of dimension 5 over Rationals> gap> IsLieSolvable( L ); true
This section contains some functions for dealing with semisimple Lie algebras and their root systems.
‣ SemiSimpleType( L ) | ( attribute ) |
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"
‣ ChevalleyBasis( L ) | ( attribute ) |
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 ] ]
‣ IsRootSystem( obj ) | ( category ) |
Category of root systems.
‣ IsRootSystemFromLieAlgebra( obj ) | ( category ) |
Category of root systems that come from (semisimple) Lie algebras. They often have special attributes such as UnderlyingLieAlgebra (64.6-6), PositiveRootVectors (64.6-9), NegativeRootVectors (64.6-10), CanonicalGenerators (64.6-14).
‣ RootSystem( L ) | ( attribute ) |
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
‣ UnderlyingLieAlgebra( R ) | ( attribute ) |
For a root system R coming from a semisimple Lie algebra L, returns the Lie algebra L.
‣ PositiveRoots( R ) | ( attribute ) |
The list of positive roots of the root system R.
‣ NegativeRoots( R ) | ( attribute ) |
The list of negative roots of the root system R.
‣ PositiveRootVectors( R ) | ( attribute ) |
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 ) (see PositiveRoots (64.6-7)). The root vector is a non-zero element of the root space (in L) of the corresponding root.
‣ NegativeRootVectors( R ) | ( attribute ) |
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 ) (see NegativeRoots (64.6-8)). The root vector is a non-zero element of the root space (in L) of the corresponding root.
‣ SimpleSystem( R ) | ( attribute ) |
A list of simple roots of the root system R.
‣ CartanMatrix( R ) | ( attribute ) |
The Cartan matrix of the root system R, relative to the simple roots in SimpleSystem( R ) (see SimpleSystem (64.6-11)).
‣ BilinearFormMat( R ) | ( attribute ) |
The matrix of the bilinear form of the root system R. If we denote this matrix by \(B\), then we have \(B(i,j) = (\alpha_i, \alpha_j)\), where the \(\alpha_i\) are the simple roots of R.
‣ CanonicalGenerators( R ) | ( attribute ) |
Here R must be a root system coming from a semisimple Lie algebra L. This function returns \(3l\) generators of L, \(x_1, \ldots, x_l, y_1, \ldots, y_l, h_1, \ldots, 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 = \delta_{ij} h_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 gap> # 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 ] ]
This section deals with the Weyl group of a root system. A Weyl group is represented by its action on the weight lattice. A weight is by definition a linear function \(\lambda: H \rightarrow F\) (where \(F\) is the ground field), such that the values \(\lambda(h_i)\) are all integers (where the \(h_i\) are the Cartan elements of the CanonicalGenerators (64.6-14)). 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 \(\lambda(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 (64.7-4).
A Weyl group is generated by the simple reflections. So GeneratorsOfGroup (39.2-4) 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.
‣ IsWeylGroup( G ) | ( property ) |
A Weyl group is a group generated by reflections, with the attribute SparseCartanMatrix (64.7-2) set.
‣ SparseCartanMatrix( W ) | ( attribute ) |
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.
‣ WeylGroup( R ) | ( attribute ) |
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 ]
‣ ApplySimpleReflection( SC, i, wt ) | ( operation ) |
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 ]
‣ LongestWeylWordPerm( W ) | ( attribute ) |
Let \(g_0\) be the longest element in the Weyl group W, and let \(\{ \alpha_1, \ldots, \alpha_l \}\) be a simple system of the corresponding root system. Then \(g_0\) maps \(\alpha_i\) to \(-\alpha_{{\sigma(i)}}\), where \(\sigma\) is a permutation of \((1, \ldots, l)\). This function returns that permutation.
gap> L:= SimpleLieAlgebra( "E", 6, Rationals );; gap> W:= WeylGroup( RootSystem( L ) );; gap> LongestWeylWordPerm( W ); (1,6)(3,5)
‣ ConjugateDominantWeight( W, wt ) | ( operation ) |
‣ ConjugateDominantWeightWithWord( W, wt ) | ( operation ) |
Here W is a Weyl group and wt a weight (i.e., a list of integers). ConjugateDominantWeight returns the unique dominant weight conjugate to wt under W.
ConjugateDominantWeightWithWord returns a list of two elements. The first of these is the dominant weight conjugate to 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 ]
‣ WeylOrbitIterator( W, wt ) | ( operation ) |
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; # this is the size of the Weyl group of E6 51840
A Lie algebra \(L\) over a field of characteristic \(p>0\) is called restricted if there is a map \(x \mapsto x^p\) from \(L\) into \(L\) (called a \(p\)-map) such that ad \(x^p = (\)ad\( x)^p\), \((\alpha x)^p = \alpha^p x^p\) and \((x+y)^p = x^p + y^p + \sum_{{i=1}}^{{p-1}} s_i(x,y)\), where \(s_i: L \times L \rightarrow L\) are certain Lie polynomials in two variables. Using these relations we can calculate \(y^p\) for all \(y \in L\), once we know \(x^p\) for \(x\) in a basis of \(L\). Therefore a \(p\)-map is represented in GAP by a list containing the images of the basis vectors of a basis \(B\) of \(L\). For this reason this list is an attribute of the basis \(B\).
‣ IsRestrictedLieAlgebra( L ) | ( property ) |
Test whether L is restricted.
gap> L:= SimpleLieAlgebra( "W", [2], GF(5)); <Lie algebra of dimension 25 over GF(5)> gap> IsRestrictedLieAlgebra( L ); false gap> L:= SimpleLieAlgebra( "W", [1], GF(5)); <Lie algebra of dimension 5 over GF(5)> gap> IsRestrictedLieAlgebra( L ); true
‣ PthPowerImages( B ) | ( attribute ) |
Here B is a basis of a restricted Lie algebra. This function returns the list of the images of the basis vectors of B under the \(p\)-map.
gap> L:= SimpleLieAlgebra( "W", [1], GF(11) ); <Lie algebra of dimension 11 over GF(11)> gap> B:= Basis( L ); CanonicalBasis( <Lie algebra of dimension 11 over GF(11)> ) gap> PthPowerImages( B ); [ 0*v.1, v.2, 0*v.1, 0*v.1, 0*v.1, 0*v.1, 0*v.1, 0*v.1, 0*v.1, 0*v.1, 0*v.1 ]
‣ PthPowerImage( B, x ) | ( operation ) |
‣ PthPowerImage( x ) | ( operation ) |
‣ PthPowerImage( x, n ) | ( operation ) |
This function computes the image of an element x of a restricted Lie algebra under its \(p\)-map.
In the first form, a basis of the Lie algebra is provided; this basis stores the \(p\)th powers of its elements. It is the traditional form, provided for backwards compatibility.
In its second form, only the element x is provided. It is the only form for elements of Lie algebras with no predetermined basis, such as those constructed by LieObject (64.1-1).
In its third form, an extra non-negative integer n is specified; the \(p\)-mapping is iterated n times on the element x.
gap> L:= SimpleLieAlgebra( "W", [1], GF(11) );; gap> B:= Basis( L );; gap> x:= B[1]+B[11]; v.1+v.11 gap> PthPowerImage( B, x ); v.1+v.11 gap> PthPowerImage( x, 2 ); v.1+v.11 gap> f := FreeAssociativeAlgebra(GF(2),"x","y"); <algebra over GF(2), with 2 generators> gap> x := LieObject(f.1);; y := LieObject(f.2);; gap> x*y; x^2; PthPowerImage(x); LieObject( (Z(2)^0)*x*y+(Z(2)^0)*y*x ) LieObject( <zero> of ... ) LieObject( (Z(2)^0)*x^2 )
‣ JenningsLieAlgebra( G ) | ( attribute ) |
Let G be a nontrivial \(p\)-group, and let \(\textit{G} = G_1 \supset G_2 \supset \cdots \supset G_m = 1\) be its Jennings series (see JenningsSeries (39.17-14)). Then the quotients \(G_i / G_{{i+1}}\) are elementary abelian \(p\)-groups, i.e., they can be viewed as vector spaces over GF\((p)\). Now the Jennings-Lie algebra \(L\) of G is the direct sum of those vector spaces. The Lie bracket on \(L\) is induced by the commutator in G. Furthermore, the map \(g \mapsto g^p\) in G induces a \(p\)-map in \(L\) making \(L\) into a restricted Lie algebra. In the canonical basis of \(L\) this \(p\)-map is added as an attribute. A Lie algebra created by JenningsLieAlgebra is naturally graded. The attribute Grading (62.9-20) is set.
‣ PCentralLieAlgebra( G ) | ( attribute ) |
Here G is a nontrivial \(p\)-group. PCentralLieAlgebra( G ) does the same as JenningsLieAlgebra (64.8-4) except that the \(p\)-central series is used instead of the Jennings series (see PCentralSeries (39.17-13)). This function also returns a graded Lie algebra. However, it is not necessarily restricted.
gap> G:= SmallGroup( 3^6, 123 ); <pc group of size 729 with 6 generators> gap> L:= JenningsLieAlgebra( G ); <Lie algebra of dimension 6 over GF(3)> gap> HasPthPowerImages( Basis( L ) ); true gap> PthPowerImages( Basis( L ) ); [ v.6, 0*v.1, 0*v.1, 0*v.1, 0*v.1, 0*v.1 ] gap> g:= Grading( L ); rec( hom_components := function( d ) ... end, max_degree := 3, min_degree := 1, source := Integers ) gap> List( [1,2,3], g.hom_components ); [ <vector space over GF(3), with 3 generators>, <vector space over GF(3), with 2 generators>, <vector space over GF(3), with 1 generator> ]
‣ NaturalHomomorphismOfLieAlgebraFromNilpotentGroup( L ) | ( attribute ) |
This is an attribute of Lie algebras created by JenningsLieAlgebra (64.8-4) or PCentralLieAlgebra (64.8-5). Then L is the direct sum of quotients of successive terms of the Jennings, or \(p\)-central series of a \(p\)-group G. Let Gi be the \(i\)-th term in this series, and let f = NaturalHomomorphismOfLieAlgebraFromNilpotentGroup( L ), then for g in Gi, f( g, i ) returns the element of L (lying in the \(i\)-th homogeneous component) corresponding to g.
In this section we show functions for calculating with the adjoint representation of a Lie algebra (and the corresponding trace form, called the Killing form) (see also AdjointBasis (62.9-5) and IndicesOfAdjointBasis (62.9-6)).
‣ AdjointMatrix( B, x ) | ( operation ) |
is the matrix of the adjoint representation of the element x w.r.t. the basis B. The adjoint map is the left multiplication by x. The \(i\)-th column of the resulting matrix represents the image of the \(i\)-th basis vector of B under left multiplication by x.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> AdjointMatrix( Basis( L ), Basis( L )[1] ); [ [ 0, 0, -2 ], [ 0, 0, 0 ], [ 0, 1, 0 ] ]
‣ AdjointAssociativeAlgebra( L, K ) | ( operation ) |
is the associative matrix algebra (with 1) generated by the matrices of the adjoint representation of the subalgebra K on the Lie algebra L.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> AdjointAssociativeAlgebra( L, L ); <algebra of dimension 9 over Rationals> gap> AdjointAssociativeAlgebra( L, CartanSubalgebra( L ) ); <algebra of dimension 3 over Rationals>
‣ KillingMatrix( B ) | ( attribute ) |
is the matrix of the Killing form \(\kappa\) with respect to the basis B, i.e., the matrix \(( \kappa( b_i, b_j ) )\) where \(b_1, b_2, \ldots\) are the basis vectors of B.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> KillingMatrix( Basis( L ) ); [ [ 0, 4, 0 ], [ 4, 0, 0 ], [ 0, 0, 8 ] ]
‣ KappaPerp( L, U ) | ( operation ) |
is the orthogonal complement of the subspace U of the Lie algebra L with respect to the Killing form \(\kappa\), that is, the set \(U^{{\perp}} = \{ x \in L; \kappa( x, y ) = 0 \hbox{ for all } y \in L \}\).
\(U^{{\perp}}\) is a subspace of L, and if U is an ideal of L then \(U^{{\perp}}\) is a subalgebra of L.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> b:= BasisVectors( Basis( L ) );; gap> V:= VectorSpace( Rationals, [b[1],b[2]] );; gap> KappaPerp( L, V ); <vector space of dimension 1 over Rationals>
‣ IsNilpotentElement( L, x ) | ( operation ) |
x is nilpotent in L if its adjoint matrix is a nilpotent matrix.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> IsNilpotentElement( L, Basis( L )[1] ); true
‣ NonNilpotentElement( L ) | ( attribute ) |
A non-nilpotent element of a Lie algebra L is an element \(x\) such that ad\(x\) is not nilpotent. If L is not nilpotent, then by Engel's theorem non-nilpotent elements exist in L. In this case this function returns a non-nilpotent element of L, otherwise (if L is nilpotent) fail is returned.
gap> L:= SimpleLieAlgebra( "G", 2, Rationals );; gap> NonNilpotentElement( L ); v.13 gap> IsNilpotentElement( L, last ); false
‣ FindSl2( L, x ) | ( function ) |
This function tries to find a subalgebra \(S\) of the Lie algebra L with \(S\) isomorphic to \(sl_2\) and such that the nilpotent element x of L is contained in \(S\). If such an algebra exists then it is returned, otherwise fail is returned.
gap> L:= SimpleLieAlgebra( "G", 2, Rationals );; gap> b:= BasisVectors( Basis( L ) );; gap> IsNilpotentElement( L, b[1] ); true gap> FindSl2( L, b[1] ); <Lie algebra of dimension 3 over Rationals>
‣ UniversalEnvelopingAlgebra( L[, B] ) | ( attribute ) |
Returns the universal enveloping algebra of the Lie algebra L. The elements of this algebra are written on a Poincare-Birkhoff-Witt basis.
If a second argument B is given, it must be a basis of L, and an isomorphic copy of the universal enveloping algebra is returned, generated by the images (in the universal enveloping algebra) of the elements of B.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> UL:= UniversalEnvelopingAlgebra( L ); <algebra-with-one of dimension infinity over Rationals> gap> g:= GeneratorsOfAlgebraWithOne( UL ); [ [(1)*x.1], [(1)*x.2], [(1)*x.3] ] gap> g[3]^2*g[2]^2*g[1]^2; [(-4)*x.1*x.2*x.3^3+(1)*x.1^2*x.2^2*x.3^2+(2)*x.3^3+(2)*x.3^4]
Finitely presented Lie algebras can be constructed from free Lie algebras by using the / constructor, i.e., FL/[r1, ..., rk] is the quotient of the free Lie algebra FL by the ideal generated by the elements r1, ..., rk of FL. If the finitely presented Lie algebra K happens to be finite dimensional then an isomorphic structure constants Lie algebra can be constructed by NiceAlgebraMonomorphism(K) (see NiceAlgebraMonomorphism (62.10-10)), which returns a surjective homomorphism. The structure constants Lie algebra can then be accessed by calling Range (32.3-7) for this map. Also limited computations with elements of the finitely presented Lie algebra are possible.
gap> L:= FreeLieAlgebra( Rationals, "s", "t" ); <Lie algebra over Rationals, with 2 generators> gap> gL:= GeneratorsOfAlgebra( L );; s:= gL[1];; t:= gL[2];; gap> K:= L/[ s*(s*t), t*(t*(s*t)), s*(t*(s*t))-t*(s*t) ]; <Lie algebra over Rationals, with 2 generators> gap> h:= NiceAlgebraMonomorphism( K ); [ [(1)*s], [(1)*t] ] -> [ v.1, v.2 ] gap> U:= Range( h ); <Lie algebra of dimension 3 over Rationals> gap> IsLieNilpotent( U ); true gap> gK:= GeneratorsOfAlgebra( K ); [ [(1)*s], [(1)*t] ] gap> gK[1]*(gK[2]*gK[1]) = Zero( K ); true
‣ FpLieAlgebraByCartanMatrix( C ) | ( function ) |
Here C must be a Cartan matrix. The function returns the finitely-presented Lie algebra over the field of rational numbers defined by this Cartan matrix. By Serre's theorem, this Lie algebra is a semisimple Lie algebra, and its root system has Cartan matrix C.
gap> C:= [ [ 2, -1 ], [ -3, 2 ] ];; gap> K:= FpLieAlgebraByCartanMatrix( C ); <Lie algebra over Rationals, with 6 generators> gap> h:= NiceAlgebraMonomorphism( K ); [ [(1)*x1], [(1)*x2], [(1)*x3], [(1)*x4], [(1)*x5], [(1)*x6] ] -> [ v.1, v.2, v.3, v.4, v.5, v.6 ] gap> SemiSimpleType( Range( h ) ); "G2"
‣ NilpotentQuotientOfFpLieAlgebra( FpL, max[, weights] ) | ( function ) |
Here FpL is a finitely presented Lie algebra. Let \(K\) be the quotient of FpL by the max+1-th term of its lower central series. This function calculates a surjective homomorphism from FpL onto \(K\). When called with the third argument weights, the \(k\)-th generator of FpL gets assigned the \(k\)-th element of the list weights. In that case a quotient is calculated of FpL by the ideal generated by all elements of weight max+1. If the list weights only consists of \(1\)'s then the two calls are equivalent. The default value of weights is a list (of length equal to the number of generators of FpL) consisting of \(1\)'s.
If the relators of FpL are homogeneous, then the resulting algebra is naturally graded.
gap> L:= FreeLieAlgebra( Rationals, "x", "y" );; gap> g:= GeneratorsOfAlgebra(L);; x:= g[1]; y:= g[2]; (1)*x (1)*y gap> rr:=[ ((y*x)*x)*x-6*(y*x)*y, > 3*((((y*x)*x)*x)*x)*x-20*(((y*x)*x)*x)*y ]; [ (-1)*(x*(x*(x*y)))+(6)*((x*y)*y), (-3)*(x*(x*(x*(x*(x*y)))))+(20)*(x*(x*((x*y)*y)))+( -20)*((x*(x*y))*(x*y)) ] gap> K:= L/rr; <Lie algebra over Rationals, with 2 generators> gap> h:=NilpotentQuotientOfFpLieAlgebra(K, 50, [1,2] ); [ [(1)*x], [(1)*y] ] -> [ v.1, v.2 ] gap> L:= Range( h ); <Lie algebra of dimension 50 over Rationals> gap> Grading( L ); rec( hom_components := function( d ) ... end, max_degree := 50, min_degree := 1, source := Integers )
Representations of Lie algebras are dealt with in the same way as representations of ordinary algebras (see 62.11). In this section we mainly deal with modules over general Lie algebras and their cohomology. The next section is devoted to modules over semisimple Lie algebras. An \(s\)-cochain of a module \(V\) over a Lie algebra \(L\) is an \(s\)-linear map
\[ c: L \times \cdots \times L \rightarrow V , \]
with \(s\) factors \(L\), that is skew-symmetric (meaning that if any of the arguments are interchanged, \(c\) changes to \(-c\)).
Let \((x_1, \ldots, x_n)\) be a basis of \(L\). Then any \(s\)-cochain is determined by the values \(c( x_{{i_1}}, \ldots, x_{{i_s}} )\), where \(1 \leq i_1 < i_2 < \cdots < i_s \leq \dim L\). Now this value again is a linear combination of basis elements of \(V\): \(c( x_{{i_1}}, \ldots, x_{{i_s}} ) = \sum \lambda^k_{{i_1,\ldots, i_s}} v_k\). Denote the dimension of \(V\) by \(r\). Then we represent an \(s\)-cocycle by a list of \(r\) lists. The \(j\)-th of those lists consists of entries of the form
\[ [ [ i_1, i_2, \ldots, i_s ], \lambda^j_{{i_1, \ldots, i_s}} ] \]
where the coefficient on the second position is non-zero. (We only store those entries for which this coefficient is non-zero.) It follows that every \(s\)-tuple \((i_1, \ldots, i_s)\) gives rise to \(r\) basis elements.
So the zero cochain is represented by a list of the form [ [ ], [ ], \ldots, [ ] ]. Furthermore, if \(V\) is, e.g., \(4\)-dimensional, then the \(2\)-cochain represented by
[ [ [ [1,2], 2] ], [ ], [ [ [1,2], 1/2 ] ], [ ] ]
maps the pair \((x_1, x_2)\) to \(2v_1 + 1/2 v_3\) (where \(v_1\) is the first basis element of \(V\), and \(v_3\) the third), and all other pairs to zero.
By definition, \(0\)-cochains are constant maps \(c( x ) = v_c \in V\) for all \(x \in L\). So \(0\)-cochains have a different representation: they are just represented by the list [ v_c ].
Cochains are constructed using the function Cochain (64.12-2), if c is a cochain, then its corresponding list is returned by ExtRepOfObj( c ).
‣ IsCochain( obj ) | ( category ) |
‣ IsCochainCollection( obj ) | ( category ) |
Categories of cochains and of collections of cochains.
‣ Cochain( V, s, obj ) | ( operation ) |
Constructs a s-cochain given by the data in obj, with respect to the Lie algebra module V. If s is non-zero, then obj must be a list.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> V:= AdjointModule( L ); <3-dimensional left-module over <Lie algebra of dimension 3 over Rationals>> gap> c1:= Cochain( V, 2, > [ [ [ [ 1, 3 ], -1 ] ], [ ], [ [ [ 2, 3 ], 1/2 ] ] ]); <2-cochain> gap> ExtRepOfObj( c1 ); [ [ [ [ 1, 3 ], -1 ] ], [ ], [ [ [ 2, 3 ], 1/2 ] ] ] gap> c2:= Cochain( V, 0, Basis( V )[1] ); <0-cochain> gap> ExtRepOfObj( c2 ); v.1 gap> IsCochain( c2 ); true
‣ CochainSpace( V, s ) | ( operation ) |
Returns the space of all s-cochains with respect to V.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> V:= AdjointModule( L );; gap> C:=CochainSpace( V, 2 ); <vector space of dimension 9 over Rationals> gap> BasisVectors( Basis( C ) ); [ <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain> ] gap> ExtRepOfObj( last[1] ); [ [ [ [ 1, 2 ], 1 ] ], [ ], [ ] ]
‣ ValueCochain( c, y1, y2, ..., ys ) | ( function ) |
Here c is an s-cochain. This function returns the value of c when applied to the s elements y1 to ys (that lie in the Lie algebra acting on the module corresponding to c). It is also possible to call this function with two arguments: first c and then the list containing y1,...,ys.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> V:= AdjointModule( L );; gap> C:= CochainSpace( V, 2 );; gap> c:= Basis( C )[1]; <2-cochain> gap> ValueCochain( c, Basis(L)[2], Basis(L)[1] ); (-1)*v.1
‣ LieCoboundaryOperator( c ) | ( function ) |
This is a function that takes an s-cochain c, and returns an s+1-cochain. The coboundary operator is applied.
gap> L:= SimpleLieAlgebra( "A", 1, Rationals );; gap> V:= AdjointModule( L );; gap> C:= CochainSpace( V, 2 );; gap> c:= Basis( C )[1];; gap> c1:= LieCoboundaryOperator( c ); <3-cochain> gap> c2:= LieCoboundaryOperator( c1 ); <4-cochain>
‣ Cocycles( V, s ) | ( operation ) |
is the space of all s-cocycles with respect to the Lie algebra module V. That is the kernel of the coboundary operator when restricted to the space of s-cochains.
‣ Coboundaries( V, s ) | ( operation ) |
is the space of all s-coboundaries with respect to the Lie algebra module V. That is the image of the coboundary operator, when applied to the space of s-1-cochains. By definition the space of all 0-coboundaries is zero.
gap> T:= EmptySCTable( 3, 0, "antisymmetric" );; gap> SetEntrySCTable( T, 1, 2, [ 1, 3 ] ); gap> L:= LieAlgebraByStructureConstants( Rationals, T );; gap> V:= FaithfulModule( L ); <left-module over <Lie algebra of dimension 3 over Rationals>> gap> Cocycles( V, 2 ); <vector space of dimension 7 over Rationals> gap> Coboundaries( V, 2 ); <vector space over Rationals, with 9 generators> gap> Dimension( last ); 5
This section contains functions for calculating information on representations of semisimple Lie algebras. First we have some functions for calculating some combinatorial data (set of dominant weights, the dominant character, the decomposition of a tensor product, the dimension of a highest-weight module). Then there is a function for creating an admissible lattice in the universal enveloping algebra of a semisimple Lie algebra. Finally we have a function for constructing a highest-weight module over a semisimple Lie algebra.
‣ DominantWeights( R, maxw ) | ( operation ) |
Returns a list consisting of two lists. The first of these contains the dominant weights (written on the basis of fundamental weights) of the irreducible highest-weight module, with highest weight maxw, over the Lie algebra with the root system R. The \(i\)-th element of the second list is the level of the \(i\)-th dominant weight. (Where the level is defined as follows. For a weight \(\mu\) we write \(\mu = \lambda - \sum_i k_i \alpha_i\), where the \(\alpha_i\) are the simple roots, and \(\lambda\) the highest weight. Then the level of \(\mu\) is \(\sum_i k_i\).)
‣ DominantCharacter( L, maxw ) | ( operation ) |
‣ DominantCharacter( R, maxw ) | ( operation ) |
For a highest weight maxw and a semisimple Lie algebra L, this returns the dominant weights of the highest-weight module over L, with highest weight maxw. The output is a list of two lists, the first list contains the dominant weights; the second list contains their multiplicities.
The first argument can also be a root system, in which case the dominant character of the highest-weight module over the corresponding semisimple Lie algebra is returned.
‣ DecomposeTensorProduct( L, w1, w2 ) | ( operation ) |
Here L is a semisimple Lie algebra and w1, w2 are dominant weights. Let \(V_i\) be the irreducible highest-weight module over L with highest weight \(w_i\) for \(i = 1, 2\). Let \(W = V_1 \otimes V_2\). Then in general \(W\) is a reducible L-module. Now this function returns a list of two lists. The first of these is the sorted list of highest weights of the irreducible modules occurring in the decomposition of \(W\) as a direct sum of irreducible modules. The second list contains the multiplicities of these weights (i.e., the number of copies of the irreducible module with the corresponding highest weight that occur in \(W\)). The algorithm uses Klimyk's formula (see [Kli68] or [Kli66] for the original Russian version).
‣ DimensionOfHighestWeightModule( L, w ) | ( operation ) |
Here L is a semisimple Lie algebra, and w a dominant weight. This function returns the dimension of the highest-weight module over L with highest weight w. The algorithm uses Weyl's dimension formula.
gap> L:= SimpleLieAlgebra( "F", 4, Rationals );; gap> R:= RootSystem( L );; gap> DominantWeights( R, [ 1, 1, 0, 0 ] ); [ [ [ 1, 1, 0, 0 ], [ 2, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, 0 ] ], [ 0, 3, 4, 8, 11, 19 ] ] gap> DominantCharacter( L, [ 1, 1, 0, 0 ] ); [ [ [ 1, 1, 0, 0 ], [ 2, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, 0 ] ], [ 1, 1, 4, 6, 14, 21 ] ] gap> DecomposeTensorProduct( L, [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ] ); [ [ [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], [ 1, 0, 0, 0 ], [ 1, 0, 1, 0 ], [ 1, 1, 0, 0 ], [ 2, 0, 0, 0 ] ], [ 1, 1, 1, 1, 1, 1, 1 ] ] gap> DimensionOfHighestWeightModule( L, [ 1, 2, 3, 4 ] ); 79316832731136
Let \(L\) be a semisimple Lie algebra over a field of characteristic \(0\), and let \(R\) be its root system. For a positive root \(\alpha\) we let \(x_{\alpha}\) and \(y_{\alpha}\) be positive and negative root vectors, respectively, both from a fixed Chevalley basis of \(L\). Furthermore, \(h_1, \ldots, h_l\) are the Cartan elements from the same Chevalley basis. Also we set
\[ x_{\alpha}^{(n)} = {{x_{\alpha}^n \over n!}}, y_{\alpha}^{(n)} = {{y_{\alpha}^n \over n!}} . \]
Furthermore, let \(\alpha_1, \ldots, \alpha_s\) denote the positive roots of \(R\). For multi-indices \(N = (n_1, \ldots, n_s)\), \(M = (m_1, \ldots, m_s)\) and \(K = (k_1, \ldots, k_s)\) (where \(n_i, m_i, k_i \geq 0\)) set
| \(x^N\) | = | \(x_{{\alpha_1}}^{(n_1)} \cdots x_{{\alpha_s}}^{(n_s)}\), |
| \(y^M\) | = | \(y_{{\alpha_1}}^{(m_1)} \cdots y_{{\alpha_s}}^{(m_s)}\), |
| \(h^K\) | = | \({{h_1 \choose k_1}} \cdots {{h_l \choose k_l}}\) |
Then by a theorem of Kostant, the \(x_{\alpha}^{(n)}\) and \(y_{\alpha}^{(n)}\) generate a subring of the universal enveloping algebra \(U(L)\) spanned (as a free \(Z\)-module) by the elements
\[ y^M h^K x^N \]
(see, e.g., [Hum72] or [Hum78, Section 26]) So by the Poincare-Birkhoff-Witt theorem this subring is a lattice in \(U(L)\). Furthermore, this lattice is invariant under the \(x_{\alpha}^{(n)}\) and \(y_{\alpha}^{(n)}\). Therefore, it is called an admissible lattice in \(U(L)\).
The next functions enable us to construct the generators of such an admissible lattice.
‣ IsUEALatticeElement( obj ) | ( category ) |
‣ IsUEALatticeElementCollection( obj ) | ( category ) |
‣ IsUEALatticeElementFamily( fam ) | ( category ) |
is the category of elements of an admissible lattice in the universal enveloping algebra of a semisimple Lie algebra L.
‣ LatticeGeneratorsInUEA( L ) | ( attribute ) |
Here L must be a semisimple Lie algebra of characteristic \(0\). This function returns a list of generators of an admissible lattice in the universal enveloping algebra of L, relative to the Chevalley basis contained in ChevalleyBasis( L ) (see ChevalleyBasis (64.6-2)). First are listed the negative root vectors (denoted by \(y_1, \ldots, y_s\)), then the positive root vectors (denoted by \(x_1, \ldots, x_s\)). At the end of the list there are the Cartan elements. They are printed as ( hi/1 ), which means
\[ {{h_i \choose 1}}. \]
In general the printed form ( hi/ k ) means
\[ {{h_i \choose k}}. \]
Also \(y_i^{(m)}\) is printed as yi^(m), which means that entering yi^m at the GAP prompt results in the output m!*yi^(m).
Products of lattice generators are collected using the following order: first come the \(y_i^{(m_i)}\) (in the same order as the positive roots), then the \({h_i \choose k_i}\), and then the \(x_i^{(n_i)}\) (in the same order as the positive roots).
‣ ObjByExtRep( F, descr ) | ( method ) |
An UEALattice element is represented by a list of the form [ m1, c1, m2, c2, ... ], where the c1, c2 etc. are coefficients, and the m1, m2 etc. are monomials. A monomial is a list of the form [ ind1, e1, ind2, e2, ... ] where ind1, ind2 are indices, and e1, e2 etc. are exponents. Let \(N\) be the number of positive roots of the underlying Lie algebra L. The indices lie between 1 and \(dim(L)\). If an index lies between 1 and N, then it represents a negative root vector (corresponding to the root NegativeRoots( R )[ind], where R is the root system of L; see NegativeRoots (64.6-8)). This leads to a factor yind1^(e1) in the printed form of the monomial (which equals z^e1/e1!, where z is a basis element of L). If an index lies between \(N+1\) and \(2N\), then it represents a positive root vector. Finally, if ind lies between \(2N+1\) and \(2N+rank\), then it represents an element of the Cartan subalgebra. This is printed as \(( h_1/ e_1 )\), meaning \({h_1 \choose e_1}\), where \(h_1, \ldots, h_{rank}\) are the canonical Cartan generators.
The zero element is represented by the empty list, the identity element by the list [ [], 1 ].
gap> L:= SimpleLieAlgebra( "G", 2, Rationals );; gap> g:=LatticeGeneratorsInUEA( L ); [ y1, y2, y3, y4, y5, y6, x1, x2, x3, x4, x5, x6, ( h13/1 ), ( h14/1 ) ] gap> IsUEALatticeElement( g[1] ); true gap> g[1]^3; 6*y1^(3) gap> q:= g[7]*g[1]^2; -2*y1+2*y1*( h13/1 )+2*y1^(2)*x1 gap> ExtRepOfObj( q ); [ [ 1, 1 ], -2, [ 1, 1, 13, 1 ], 2, [ 1, 2, 7, 1 ], 2 ]
‣ IsWeightRepElement( obj ) | ( category ) |
‣ IsWeightRepElementCollection( obj ) | ( category ) |
‣ IsWeightRepElementFamily( fam ) | ( category ) |
Is a category of vectors, that is used to construct elements of highest-weight modules (by HighestWeightModule (64.14-5)).
WeightRepElements are represented by a list of the form [ v1, c1, v2, c2, ....], where the vi are basis vectors, and the ci are coefficients. Furthermore a basis vector v is a weight vector. It is represented by a list of the form [ k, mon, wt ], where k is an integer (the basis vectors are numbered from \(1\) to \(\dim V\), where \(V\) is the highest weight module), mon is an UEALatticeElement (which means that the result of applying mon to a highest weight vector is v; see IsUEALatticeElement (64.14-1)) and wt is the weight of v. A WeightRepElement is printed as mon*v0, where v0 denotes a fixed highest weight vector.
If v is a WeightRepElement, then ExtRepOfObj( v ) returns the corresponding list, and if list is such a list and fam a WeightRepElementFamily, then ObjByExtRep( list, fam ) returns the corresponding WeightRepElement.
‣ HighestWeightModule( L, wt ) | ( operation ) |
returns the highest weight module with highest weight wt of the semisimple Lie algebra L of characteristic \(0\).
Note that the elements of such a module lie in the category IsLeftAlgebraModuleElement (62.11-9) (and in particular they do not lie in the category IsWeightRepElement (64.14-4)). However, if v is an element of such a module, then ExtRepOfObj( v ) is a WeightRepElement.
Note that for the following examples of this chapter we increase the line length limit from its default value 80 to 81 in order to make some long output expressions fit into the lines.
gap> K1:= SimpleLieAlgebra( "G", 2, Rationals );; gap> K2:= SimpleLieAlgebra( "B", 2, Rationals );; gap> L:= DirectSumOfAlgebras( K1, K2 ); <Lie algebra of dimension 24 over Rationals> gap> V:= HighestWeightModule( L, [ 0, 1, 1, 1 ] ); <224-dimensional left-module over <Lie algebra of dimension 24 over Rationals>> gap> vv:= GeneratorsOfLeftModule( V );; gap> vv[100]; y5*y7*y10*v0 gap> e:= ExtRepOfObj( vv[100] ); y5*y7*y10*v0 gap> ExtRepOfObj( e ); [ [ 100, y5*y7*y10, [ -3, 2, -1, 1 ] ], 1 ] gap> Basis(L)[17]^vv[100]; -1*y5*y7*y8*v0-1*y5*y9*v0
‣ TensorProductOfAlgebraModules( list ) | ( operation ) |
‣ TensorProductOfAlgebraModules( V, W ) | ( operation ) |
Here the elements of list must be algebra modules. The tensor product is returned as an algebra module. The two-argument version works in the same way and returns the tensor product of its arguments.
gap> L:= SimpleLieAlgebra("G",2,Rationals);; gap> V:= HighestWeightModule( L, [ 1, 0 ] );; gap> W:= TensorProductOfAlgebraModules( [ V, V, V ] ); <343-dimensional left-module over <Lie algebra of dimension 14 over Rationals>> gap> w:= Basis(W)[1]; 1*(1*v0<x>1*v0<x>1*v0) gap> Basis(L)[1]^w; <0-tensor> gap> Basis(L)[7]^w; 1*(1*v0<x>1*v0<x>y1*v0)+1*(1*v0<x>y1*v0<x>1*v0)+1*(y 1*v0<x>1*v0<x>1*v0)
‣ ExteriorPowerOfAlgebraModule( V, k ) | ( operation ) |
Here V must be an algebra module, defined over a Lie algebra. This function returns the k-th exterior power of V as an algebra module.
gap> L:= SimpleLieAlgebra("G",2,Rationals);; gap> V:= HighestWeightModule( L, [ 1, 0 ] );; gap> W:= ExteriorPowerOfAlgebraModule( V, 3 ); <35-dimensional left-module over <Lie algebra of dimension 14 over Rationals>> gap> w:= Basis(W)[1]; 1*(1*v0/\y1*v0/\y3*v0) gap> Basis(L)[10]^w; 1*(1*v0/\y1*v0/\y6*v0)+1*(1*v0/\y3*v0/\y5*v0)+1*(y1*v0/\y3*v0/\y4*v0)
‣ SymmetricPowerOfAlgebraModule( V, k ) | ( operation ) |
Here V must be an algebra module. This function returns the k-th symmetric power of V (as an algebra module).
gap> L:= SimpleLieAlgebra("G",2,Rationals);; gap> V:= HighestWeightModule( L, [ 1, 0 ] );; gap> W:= SymmetricPowerOfAlgebraModule( V, 3 ); <84-dimensional left-module over <Lie algebra of dimension 14 over Rationals>> gap> w:= Basis(W)[1]; 1*(1*v0.1*v0.1*v0) gap> Basis(L)[2]^w; <0-symmetric element> gap> Basis(L)[7]^w; 3*(1*v0.1*v0.y1*v0)
generated by GAPDoc2HTML