58 Lie Algebras

A Lie algebra L is an algebra such that xx = 0 and x(yz)+y(zx)+z(xy) = 0 for all x,y,z Î 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 ref:lie objects);

Sections

  1. Lie objects
  2. Constructing Lie algebras
  3. Distinguished Subalgebras
  4. Series of Ideals
  5. Properties of a Lie Algebra
  6. Direct Sum Decompositions
  7. Semisimple Lie Algebras
  8. Restricted Lie algebras
  9. The Adjoint Representation
  10. Universal Enveloping Algebras
  11. Finitely Presented Lie Algebras

58.1 Lie objects

Let x be a ring element, then LieObject(x) 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 * r2. 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.

  • LieObject( obj ) A

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

    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 ) C
  • IsLieObjectCollection( obj ) C

    An object lies in IsLieObject if and only if it lies in a family constructed by LieFamily.

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

    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 ); this bijection respects addition and additive inverses.

  • UnderlyingFamily( Fam ) A

    If Fam is a Lie family then UnderlyingFamily( Fam ) is a family F such that Fam = LieFamily( F ).

    58.2 Constructing Lie algebras

    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 ref:algebras.

  • LieAlgebraByStructureConstants( R, sctable ) F
  • LieAlgebraByStructureConstants( R, sctable, name ) F
  • LieAlgebraByStructureConstants( R, sctable, name1, name2, ... ) F

    LieAlgebraByStructureConstants does the same as AlgebraByStructureConstants, except that the result is assumed to be a Lie algebra. Note that the function does not check whether sctable 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>
    

  • LieAlgebra( L ) F
  • LieAlgebra( F, gens ) F
  • LieAlgebra( F, gens, zero ) F
  • LieAlgebra( F, gens, "basis" ) F
  • LieAlgebra( F, gens, zero, "basis" ) F

    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 ref:lie objects). 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 ) F
  • FreeLieAlgebra( R, rank, name ) F
  • FreeLieAlgebra( R, name1, name2, ... ) F

    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 ) F
  • MatrixLieAlgebra( R, n ) F
  • MatLieAlgebra( R, n ) F

    is the full matrix Lie algebra R n ×n , for a ring R and a nonnegative integer n.

    gap> FullMatrixLieAlgebra( GF(9), 10 );
    <Lie algebra over GF(3^2), with 19 generators>
    

  • Derivations( B ) A

    is the matrix Lie algebra of derivations of the algebra A with basis B.

    A derivation is a linear map D: A ® A with the property D( a b ) = D(a) b + a D(b).

    With respect to the basis B of A, the derivation D is described by the matrix [ di,j ] which means that D maps bi to åj = 1n dij bj.

    The set of derivations of A forms a Lie algebra with product given by (D1 D2)(a) = D1(D2(a)) - D2(D1(a)).

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

    This function constructs the simple Lie algebra of type type and of rank n over the field F.

    type must be one of A, B, C, D, E, F, G, H, K, S, W. For the types A to G, n must be a positive integer. The last four 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 other types, S and W, n must be a list of positive integers of any length. In some cases the Lie algebra returned by this function is not simple. Examples are the Lie algebras of type An over a field of characteristic p > 0 where p divides n+1, and the Lie algebras of type Kn where n is a list of length 1.

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

    58.3 Distinguished Subalgebras

    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 ) A
  • LieCenter( L ) A

    The Lie centre of the Lie algebra L is the kernel of the adjoint mapping, that is, the set { a Î L; "x Î L:a x = 0 }.

    In characteristic 2 this may differ from the usual centre (that is the set of all a Î L such that ax = xa for all x Î L). Therefore, this operation is named LieCentre and not Centre.

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

    is the annihilator of S in the Lie algebra L, that is, the set { a Î L; "s Î 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 ) O

    is the normalizer of the subspace U in the Lie algebra L, that is, the set NL(U) = { x Î L; [x,U] Ì 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 ) A

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

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

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

    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>
    

    58.4 Series of Ideals

  • LieDerivedSeries( L ) A

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

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

    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 over Rationals, with 0 generators> ]
    

    58.5 Properties of a Lie Algebra

  • IsLieAbelian( L ) P

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

    A Lie algebra L is defined to be (Lie) it 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 ) P

    A Lie algebra L is defined to be (Lie) it 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
    

    58.6 Direct Sum Decompositions

    In this section we describe two functions that calculate a direct sum decomposition of a Lie algebra; the so-called Levi decomposition and the decomposition into a direct sum of ideals.

  • LeviMalcevDecomposition( L ) A

    A Levi-Malcev subalgebra of the algebra L is a semisimple subalgebra complementary to the radical of L. This function returns a list with two components. The first component is a Levi-Malcev subalgebra, the second the radical. This function is implemented for associative and Lie algebras.

    gap> L:= FullMatrixLieAlgebra( Rationals, 5 );; 
    gap> LeviMalcevDecomposition( L );
    [ <Lie algebra of dimension 24 over Rationals>, 
      <two-sided ideal in <Lie algebra of dimension 25 over Rationals>, 
          (dimension 1)> ]
    

  • DirectSumDecomposition( L ) A

    This function calculates a list of ideals of the algebra L such that L is equal to their direct sum. Currently this is only implemented for semisimple associative algebras, and Lie algebras (semisimple or not).

    gap> L:= FullMatrixLieAlgebra( Rationals, 5 );; 
    gap> DirectSumDecomposition( L );
    [ <two-sided ideal in 
          <two-sided ideal in <Lie algebra of dimension 25 over Rationals>, 
              (dimension 1)>, (dimension 1)>, 
      <two-sided ideal in <two-sided ideal in 
              <Lie algebra of dimension 25 over Rationals>, (dimension 24)>, 
          (dimension 24)> ]
    

    58.7 Semisimple Lie Algebras

    In this section we list some functions that create and operate on semisimple Lie algebras.

  • RootSystem( L ) A

    RootSystem calculates the root system of the semisimple Lie algebra L with a split Cartan subalgebra. The output is a record with the following components:

    -
    roots the set of roots of L with respect to the Cartan subalgebra that is output by CartanSubalgebra( L ). First the positive roots are listed according to increasing height. The second half of the list consists of the negative roots.
    -
    rootvecs the set of elements of L that are root vectors corresponding to the roots in roots (i.e., the first vector spanns the root space corresponding to the forst root in roots and so on).
    -
    fundroots a set of fundamental roots
    -
    cartanmat the Cartan matrix of the set of fundamental roots.

    gap> L:= SimpleLieAlgebra( "G", 2, Rationals );
    <Lie algebra of dimension 14 over Rationals>
    gap> RootSystem( L );
    rec(
      roots := [ [ 1, -1 ], [ 0, 1 ], [ 1, 0 ], [ 2, -1 ], [ 3, -2 ], [ 3, -1 ], 
          [ -1, 1 ], [ 0, -1 ], [ -1, 0 ], [ -2, 1 ], [ -3, 2 ], [ -3, 1 ] ],
      rootvecs := [ v.1, v.2, v.3, v.4, v.5, v.6, v.7, v.8, v.9, v.10, v.11, v.12 
         ],
      fundroots := [ [ 1, -1 ], [ 0, 1 ] ],
      cartanmat := [ [ 2, -1 ], [ -3, 2 ] ] )
    

  • SemiSimpleType( L ) A

    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"
    

    58.8 Restricted Lie algebras

    A Lie algebra L over a field of characteristic p > 0 is called restricted if there is a map x® xp from L into L (called a p-map) such that ad xp = (ad x)p, (ax)p = ap xp and (x+y)p = xp+yp+åi = 1p-1 si(x,y), where si: L×L® L are certain Lie polynomials in two variables. Using these relations we can calculate yp for all y Î L, once we know xp 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 ) P

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

    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 );
    Basis( <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 ) O

    B is a basis of a restricted Lie algebra L. This function calculates for an element x of L the image of x under the p-map.

    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
    

  • JenningsLieAlgebra( G ) A

    Let G be a p-group, and let G = G1 É G2 É ¼ É Gm = 1 be its Jennings series. Then the quotients Gi/Gi+1 are elementary Abelian p-groups, i.e., they are isomorphic to vector spaces over GFp. 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® gp 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( G ) is naturally graded. The attribute Grading is set.

    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( min_degree := 1, max_degree := 3, source := Integers, 
      hom_components := function( d ) ... end )
    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 generators> ]
    

    58.9 The Adjoint Representation

    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 ref:adjointbasis and ref:indicesofadjointbasis).

  • AdjointMatrix( B, x ) O

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

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

    is the matrix of the Killing form k with respect to the basis B, i.e., the matrix (k(bi,bj)) where b1,b2¼ 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 ) O

    is the orthogonal complement of the subspace U of the Lie algebra L with respect to the Killing form k, that is, the set U^ = { x Î L; k(x,y) = 0 for all y Î L }.

    U^ is a subspace of L, and if U is an ideal of L then U^ 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 ) O

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

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

    This function tries to find a subalgebra S of the Lie algebra L with S isomorphic to sl2 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>
    

    58.10 Universal Enveloping Algebras

  • UniversalEnvelopingAlgebra( L ) A

    Returns the universal enveloping algebra of the Lie algebra L. The elements of this algebra are written on a Poincare-Birkhoff-Witt basis.

    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]
    

    58.11 Finitely Presented Lie Algebras

    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), which returns a surjective homomorphism. The structure constants Lie algebra can then be accessed by calling Range 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 ) F

    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 ) F
  • NilpotentQuotientOfFpLieAlgebra( FpL, max, weights ) F

    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 of 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.par 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( min_degree := 1, max_degree := 50, source := Integers, 
      hom_components := function( d ) ... end )
    

    [Top] [Previous] [Up] [Next] [Index]

    GAP 4 manual
    July 1999