Application Center - Maplesoft

App Preview:

Lie algebra package

You can switch back to the summary page by clicking here.

Learn about Maple
Download Application



Introduction to the Lie Algebra Package

by Yuly Billig ( and Matthias Mazzag (


  • The liealg package can be used to perform calculations using infinite dimensional Lie algebras.
  • Functions available are:

&< &<= &<> &= &> &>=

delete delta directsum factoralg field genbasis

generators genhallmon ideal isgenerator KacMoody simple

simplify store symbasis triangular using wt

  • The overloaded &* (non-commutative multiplication) operator notates a Lie algebra product. Note that when using constants inside an expression, always indicate the constant part by placing brackets around the constant and the term that's being multiplied. For example z &* 3 * y w ill result in 3 * z * y, s o instead use z &* (3 * y) which gives the correct form 3 * (z &* y).
  • To use the liealg library download the files liealg.m (contains the interface) and hidden.m (contains supporting operations used by the library). Set the Maple environment variable libname so that it includes the directory where the files are located. Use the with(liealg) command to load all the functions in the library. Note that you need to load only liealg it automatically loads the hidden library if placed in the same directory.


> restart;

> libname := "C:\\Program Files\\Maple 6\\Users\\Yuly Bilig", libname; with(liealg):

libname :=

Warning, the name expand has been redefined

Warning, the protected name simplify has been redefined and unprotected

Free Lie algebra

An example computation in free Lie algebra.
Define the set of generators for algebra L and allow the generators() function to assign default weights to them.

> generators(L,[x,y,z]);

L = [x, y, z], [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

Simplify the expression in L.

> simplify(y&*x);


A more comlex simplification.

> a:=x&*y; b:=y&*z; simplify(a&*b);

a := `&*`(x,y)

b := `&*`(y,z)


Calculate the weight of the resulting expression.

> wt(%);

[1, 2, 1]

Generate Hall Monomials in L of the given weight.

> genhallmon([1,2,1],L);

[`&*`(`&*`(`&*`(x,z),y),y), `&*`(`&*`(`&*`(x,y),z),...

Free Lie algebra with another grading

Define another set of generators for algebra L2. We also supply the generators() function with our own weights for the

> generators(L2,[x,y,z],[[1],[1],[1]]);

L2 = [x, y, z], [[1], [1], [1]]

With the definition of an algebra the default algebra changes to the newly defined algebra. The default algebra is used
when no algebra is specified for Lie algebra computations. Without any arguments using() displays the algebra currently in
use along with its generators. With using(algname) we can change the default agebra to the desired.

> using();

L2 = [x, y, z]

Calculate the weight of the expression using the user defined weights.

> wt(((x&*y)&*z)&*x);


Generating Hall Monomials in L2 with weight [4].

> genhallmon([4],L2);

[`&*`(`&*`(`&*`(x,y),y),y), `&*`(`&*`(`&*`(x,y),y),...
[`&*`(`&*`(`&*`(x,y),y),y), `&*`(`&*`(`&*`(x,y),y),...
[`&*`(`&*`(`&*`(x,y),y),y), `&*`(`&*`(`&*`(x,y),y),...


An example showing how to use the sl(2) algebra in the liealg pacakge.

> generators(sl2,[e,h,f],[[1],[0],[-1]]);

sl2 = [e, h, f], [[1], [0], [-1]]

Use the store() command to store the simplification rules for the algebra.

> store([h&*e=2*e,h&*f=-2*f,e&*f=h]);

`&*`(h,e) = 2*e

`&*`(e,h) = -2*e

`&*`(h,f) = -2*f

`&*`(f,h) = 2*f

`&*`(e,f) = h

`&*`(f,e) = -h

Simplify an sl(2) expression.

> simplify((e&*f)&*(e+f));


Virasoro algebra

Setting up the Virasovo algebra's generators with their weights and simplification rules.

> generators(V,[e[i],z],[[i],[0]]); store([e[i]&*e[j]=(j-i)*e[i+j]+delta[i,-j]*i*z, e[i]&*z=0]);

V = [e[i], z], [[i], [0]]

`&*`(e[i],e[j]) = (j-i)*e[i+j]+delta[i,-j]*i*z

`&*`(e[j],e[i]) = -(j-i)*e[i+j]-delta[i,-j]*i*z

`&*`(e[i],z) = 0

`&*`(z,e[i]) = 0

Simplifying an expression in V.

> simplify(e[3]&*e[-3]);


Simple finite-dimensional algebras

Defining simple algebra F of type F[4].

> simple(F, F[4]);

F = [e[k1,k2,k3,k4], h[i1]], [[k1, k2, k3, k4], [0,...

The matrix generated for F. The general naming convention is that the matrix is called A_ algname .

> eval(A_F);

matrix([[2, -1, 0, 0], [-1, 2, -2, 0], [0, -1, 2, -...

Simplification of expressions in F.

> simplify(e[1,0,0,0]&*e[0,1,0,0]);

> simplify(e[1,1,1,1]&*e[1,1,0,0]);

> simplify(e[2,2,1,1]&*e[1,0,0,0]);

> simplify(e[-1,-2,-1,-1]&*e[1,2,1,1]);





Factor-algebras of a free Lie algebra

To build factor-algebras first define and algebra (P in our case) with its generators.

> generators(P,[x,y]);

P = [x, y], [[1, 0], [0, 1]]

Then an ideal (K in this example).

> ideal(K,[x&*(x&*(x&*y)),((x&*y)&*y)&*y]);

K = [`&*`(x,`&*`(x,`&*`(x,y))), `&*`(`&*`(`&*`(x,y)...

Define the factor-algebra S.

> factoralg(S,[P,K]);

S = [P, K]

Simplifying an expression in S and generating basis for the factor-algebra.

> simplify(x&*(y&*(x&*(y&*x))),S);

> genbasis([3,2],S);

> genbasis([4,2],S);




Kac-Moody algebras

Defining Kac-Moody algebra G. KacMoody() sets up three algebras with names algname _plus, algname _zero and
algname _minus that have positive, zero and negative weights respectively.

> C:=matrix([[2,-3],[-3,2]]);

> KacMoody(G,C);

C := matrix([[2, -3], [-3, 2]])

G = [G_plus, G_zero, G_minus]

Simplifying expressions in G and generating basis for weight [4,4] in the positive algebra G_plus.

> simplify(((((e[1]&*e[2])&*e[1])&*e[2])&*f[1]),G);

> simplify(e[1]&*(e[1]&*(e[1]&*(e[1]&*e[2]))),G);

> genbasis([4,4],G_plus);