LieAlgebra Lessons - Maple Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : DifferentialGeometry : Lessons and Tutorials : LieAlgebras : DifferentialGeometry/LessonsAndTutorials/LieAlgebras/Query

LieAlgebra Lessons

 

Lesson 5:  Query

 

 

Overview

Check that the Jacobi identity holds

Check if a Lie algebra is Abelian, nilpotent, solvable or semisimple

Determine if a subspace of a Lie algebra is a subalgebra or an ideal

Determine if a matrix defines a derivation on a Lie algebra

Determine if a matrix defines a homomorphism between two Lie algebras

Overview

In this lesson you will learn to use the LieAlgebras Query command to do the following:

– 

Check that the Jacobi identity holds.

– 

Check if a Lie algebra is Abelian, nilpotent, solvable or semisimple.

– 

Determine if a subspace of a Lie algebra is a subalgebra.

– 

Determine if a subspace of a Lie algebra is an ideal.

– 

Determine if a matrix defines a derivation on a Lie algebra.

– 

Determine if a matrix defines a homomorphism between two Lie algebras.

 

Other attributes of Lie algebras and their subalgebras can be tested. See the Query help page for details.

 

Check that the Jacobi identity holds

A bracket operation [ , ] on a vector space g defines a Lie bracket if it is bi-linear, skewsymmetric and satisfies the Jacobi identity [[x, y], z] + [[z, x], y] + [[y, z], x] = 0 for all x, y, z in g. When a Lie algebra data structure is created using the LieAlgebraData command, the validity of the Jacobi identity is not checked. (In most applications, one know  a priori that the Jacobi identities will hold and, for large dimensional Lie algebras, this is a very computational expense check.) The Query command, with the optional argument "Jacobi" will verify the Jacobi identity.

 

with(DifferentialGeometry): with(LieAlgebras):

 

Define some structure equations and initialize. These structure equations depend upon parameters {a, b, c}.

Alg1 > 

StructureEquations := [[x2, x3] = x1, [x1, x4] = x1, [x2, x4 ] = a*x3, [x3, x4] = b*x3 +c*x4];

StructureEquationsx2,x3=x1,x1,x4=x1,x2,x4=ax3,x3,x4=bx3+cx4

(2.1)
Alg1 > 

L := LieAlgebraData(StructureEquations, [x1, x2, x3, x4], Alg1);

Le1,e4=e1,e2,e3=e1,e2,e4=ae3,e3,e4=be3+ce4

(2.2)
Alg1 > 

DGsetup(L);

Lie algebra: Alg1

(2.3)

 

Check the Jacobi identity for StructureEquations.

Alg1 > 

Query(Alg1, "Jacobi");

false

(2.4)

 

It is important to understand that this means that for generic values of {a,b,c} the Jacobi identities do not hold. There may be exceptional values of the parameters

for which the Jacobi identities do hold. These exceptional values can be found by including the parameter set in the argument list for the Query command.

Alg1 > 

TF, Eq, Soln, L := Query(Alg1, {a,b,c}, "Jacobi");

TF,Eq,Soln,Ltrue,0,c,ca,b+1,b=1,c=0,a=a,e1,e4=e1,e2,e3=e1,e2,e4=ae3,e3,e4=e3

(2.5)

 

With this calling sequence the Query program returns a sequence of 4 results. The first is true/false where true means that there exist parameter values for which the Jacobi identity holds.  The second is the list of equations that must be satisfied by the parameters for the Jacobi identities to hold. The third result is the list of solutions to these equations and the fourth is the result of back--substituting these solutions into the structure equations. Note: The names given to the Lie algebras in the list L are the strings "Alg_1", "Alg_2", ... , where Alg is the name of the Lie algebra used in the first argument to Query.

Alg1 > 

DGsetup(L[1]);

Lie algebra: Alg1_1

(2.6)
Alg1_1 > 

Query("Alg1_1","Jacobi");

true

(2.7)

 

 

Check if a Lie algebra is Abelian, nilpotent, solvable or semisimple

 

Alg1_1 > 

restart: with(DifferentialGeometry): with(LieAlgebras):

 

We define 5 matrix algebras and use the Query command to determine which are Abelian, nilpotent, solvable and semisimple.

 

Matrix algebra 1:

M[1] := [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1],[0, 0]])];

M11001,0100

(3.1)

 

Matrix algebra 2:

M[2] := [op(M[1]), Matrix([[1, 0],[0, -1]])];

M21001,0100,1001

(3.2)

 

Matrix algebra 3:

M[3] := [op(M[2]), Matrix([[0, 0],[1, 0]])];

M31001,0100,1001,0010

(3.3)

 

Matrix algebra 4:

M[4] := M[3][2..4];

M40100,1001,0010

(3.4)

 

Matrix algebra 5:

M[5] := [Matrix([[0, 1, 0],[0, 0, 0], [0, 0, 0]]),Matrix([[0, 0, 1],[0, 0, 0],[0, 0, 0]]), Matrix([[0, 0, 0],[0, 0, 1],[0, 0, 0]])];

M5010000000,001000000,000001000

(3.5)

 

Calculate the structure equations for each matrix algebra and initialize.

for i to 5 do L[i] := LieAlgebraData(M[i],Alg||i); DGsetup(L[i]) od;

L1

Lie algebra: Alg1

L2e2,e3=2e2

Lie algebra: Alg2

L3e2,e3=2e2,e2,e4=e3,e3,e4=2e4

Lie algebra: Alg3

L4e1,e2=2e1,e1,e3=e2,e2,e3=2e3

Lie algebra: Alg4

L5e1,e3=e2

Lie algebra: Alg5

(3.6)
Alg5 > 

Query(Alg5,"Abelian"), Query(Alg5,"Nilpotent"), Query(Alg5, "Solvable"), Query(Alg5, "Semisimple");

false,true,true,false

(3.7)

 

We can readily check the properties of all 5 matrix algebras as follows:

Alg5 > 

Property := ["Abelian", "Nilpotent", "Solvable", "Semisimple"];

PropertyAbelian,Nilpotent,Solvable,Semisimple

(3.8)
Alg5 > 

Matrix(5,4,(i,j)-> Query(Alg||i,Property[j]));

truetruetruefalsefalsefalsetruefalsefalsefalsefalsefalsefalsefalsefalsetruefalsetruetruefalse

(3.9)
Alg5 > 

 

 

Determine if a subspace of a Lie algebra is a subalgebra or an ideal

 

A list of vectors S defines a basis for a Lie subalgebra if [x, y] in span(S) for all x, y in S.  The list S is a basis for an ideal in the Lie algebra g if [x,y] in span(S) for all x in S and y in g.With the Query command we can determine if a subspace of a Lie algebra is a subalgebra and if a subalgebra is an ideal.

 

We Retrieve a Lie algebra from the DifferentialGeometry Library and initialize it with the DGsetup command. Then we use the Query command to check if some

lists of vectors are basis for subalgebras or ideals.

 

Alg1 > 

with(DifferentialGeometry): with(LieAlgebras):with(Library);

Browse,References,Retrieve,Search

(4.1)
Alg5 > 

L := Retrieve("Winternitz", 1, [6,11],Alg);

Le1,e2=e3,e1,e3=e4,e1,e4=e5,e2,e3=e6

(4.2)
Alg5 > 

DGsetup(L);

Lie algebra: Alg

(4.3)

 

We define 2 dimensional subspaces S of the Lie algebra Alg depending on parameters {a, b, c, d}

Alg > 

S := evalDG([e4 +a*e1 + b*e6, e5 + d*e2+ c*e6]);

Sae1+e4+be6,de2+e5+ce6

(4.4)
Alg > 

Query(S, "Subalgebra");

false

(4.5)

 

This means that for generic values of the parameters {a, b, c, d} the subspace S is not a subalgebra. If we include the parameter set in the Query calling sequence, then we can determine if there are exceptional values of the parameters for which S is a subalgebra.

 

The Query command now returns a sequence of 4 results. The  first result is true if there is a value of the parameters for which S is a subalgebra, the second result is the list of equations that the parameters must satisfy for S to be subalgebra, then third result is the solution to these equations obtained from the Maple solve command, and the fourth result is the list of  subalgebras obtained from these solutions.

Alg > 

TF, Eq, Soln, T := Query(S, {a,b, c, d} ,"Subalgebra");

TF,Eq,Soln,Ttrue,0,ad,a=0,c=c,d=d,b=b,d=0,c=c,a=a,b=b,e4+be6,de2+e5+ce6,ae1+e4+be6,e5+ce6

(4.6)

 

We see that that if either a =0 then d = 0 then  S becomes a subalgebra.

Alg > 

Query(T[1],"Subalgebra");

true

(4.7)
Alg > 

Query(T[2],"Subalgebra");

true

(4.8)

 

From the 1 parameter family of subalgebras T[1], we find a 1 parameter family of ideals.

Alg > 

TF1, Eq1, Soln1, U := Query(T[1], {b, c, d}, "Ideal");

TF1,Eq1,Soln1,Utrue,0,c,d,d,c=0,d=0,b=b,e4+be6,e5

(4.9)

 

From the 1 parameter family of subalgebras T[2], we arrive at the same 1 parameter family of ideals.

Alg > 

TF2, Eq2, Soln2, V := Query(T[2], {a, b, c}, "Ideal");

TF2,Eq2,Soln2,Vtrue,0,a,c,a2,ab,a=0,c=0,b=b,e4+be6,e5

(4.10)
Alg > 

Query(U[1], "Ideal");

true

(4.11)
Alg > 

Tools:-DGequal(U[1], V[1]);

true

(4.12)

 

Determine if a matrix defines a derivation on a Lie algebra

A matrix A is a derivation for a Lie algebra g if the associated linear transformation mapping g to g satisfies A([x, y]) = [A(x), y] + [x, A(y)] for all x, y in g.

In this paragraph we shall initialize a 5 dimensional Lie algebra Alg, define a matrix A depending upon parameters {a, b, c, d, e} and use the Query program to  determine all the parameter values for which the matrix A is a derivation on g.  See also the LieAlgebras commands Adjoint , Derivations.

 

Alg > 

with(DifferentialGeometry): with(LieAlgebras):with(Library):

 

We Retrieve a Lie algebra from the DifferentialGeometry Library and initialize it with the DGsetup command.

Alg > 

L := Retrieve("Winternitz", 1, [5, 27], Alg);

Le1,e5=e1,e2,e3=e1,e3,e5=e3+e4,e4,e5=e1+e4

(5.1)
Alg > 

DGsetup(L):

 

Define a 5x5 diagonal matrix A.

Alg > 

A := LinearAlgebra:-DiagonalMatrix([a, b, c, d, e]);

Aa00000b00000c00000d00000e

(5.2)
Alg > 

TF, Eq, Soln, B := Query(Alg, A, {a,b,c,d,e},"Derivation");

TF,Eq,Soln,Btrue,0,e,d+e+c,a+e+d,a+c+b,a=d,d=d,e=0,c=d,b=0,d00000000000d00000d000000

(5.3)
Alg > 

Query(Alg, B[1],"Derivation");

true

(5.4)

 

We can use the Derivations command and the GetComponents command to find that the derivation is not an inner derivation, that is, ad(x) for for some vector x

in Alg (see Adjoint).

Alg > 

Der := Derivations("Inner");

Der1001000000001000011000000,0100000000000010000000000,0010000000000000000000000,0000100000000000000000000,0000000000000000000100000

(5.5)
Alg > 

GetComponents(B, Der);

(5.6)

 

 

Determine if a matrix defines a homomorphism between two Lie algebras

A matrix A defines a Lie algebra homomorphism from g to k if the linear transformation T: g -> k determined by A satisfies T([x,y]) = [T(x), T(y)] for all x, y in g

In this section we shall initialize Lie algebra Alg1 and Alg2  define a matrix A depending upon parameters {a, b, c, d, e} and use the Query program to determine all the parameter values for which the matrix A is a homomorphism from Alg1 to Alg2.

 

Alg > 

L1 := Retrieve("Winternitz", 1, [5, 27], Alg1);

L1e1,e5=e1,e2,e3=e1,e3,e5=e3+e4,e4,e5=e1+e4

(6.1)
Alg > 

DGsetup(L1):

Alg1 > 

L2 := _DG([["LieAlgebra", Alg2, [3]], [[[1, 2, 1], 1], [[1, 2, 3], 1], [[2, 3, 3], -1]]]);

L2e1,e2=e1+e3,e2,e3=e3

(6.2)
Alg1 > 

DGsetup(L2):

Alg2 > 

 

Alg1 > 

A := Matrix([[0,0,1,0,0], [0, 0, 0, 0, 1], [a, b, c, d, e]]);

A0010000001abcde

(6.3)
Alg2 > 

TF, Eq, Soln, phi:= Query(Alg1, Alg2, A, {a, b, c, d, e}, "Homomorphism");

TF,Eq,Soln,φtrue,0,b,a,b,a,d+1,d1,a=0,d=1,e=e,c=c,b=0,e1,0e1,e2,0e1,e3,e1+ce3,e4,e3,e5,e2+ee3

(6.4)

 

Thus there is a 2 parameter family of homomorphisms from Alg1 to Alg2 of the form given by the matrix A.

Alg2 > 

Query(phi[1],"Homomorphism");

true

(6.5)
Alg1 > 

 

 


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam