liealg_overview.mws
Introduction to the Lie Algebra Package
by Yuly Billig (billig@math.carleton.ca) and Matthias Mazzag (m.mazzag@unb.ca)
Description

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 &* (noncommutative 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.
Initialization
>
restart;
>
libname := "C:\\Program Files\\Maple 6\\Users\\Yuly Bilig", libname; with(liealg):
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]);
Simplify the expression in L.
>
simplify(y&*x);
A more comlex simplification.
>
a:=x&*y; b:=y&*z; simplify(a&*b);
Calculate the weight of the resulting expression.
>
wt(%);
Generate Hall Monomials in L of the given weight.
>
genhallmon([1,2,1],L);
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.
>
generators(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();
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);
sl(2)
An example showing how to use the sl(2) algebra in the liealg pacakge.
>
generators(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]);
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]=(ji)*e[i+j]+delta[i,j]*i*z, e[i]&*z=0]);
Simplifying an expression in V.
>
simplify(e[3]&*e[3]);
Simple finitedimensional algebras
Defining simple algebra F of type F[4].
>
simple(F, F[4]);
The matrix generated for F. The general naming convention is that the matrix is called A_
algname
.
>
eval(A_F);
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]);
Factoralgebras of a free Lie algebra
To build factoralgebras first define and algebra (P in our case) with its generators.
>
generators(P,[x,y]);
Then an ideal (K in this example).
>
ideal(K,[x&*(x&*(x&*y)),((x&*y)&*y)&*y]);
Define the factoralgebra S.
>
factoralg(S,[P,K]);
Simplifying an expression in S and generating basis for the factoralgebra.
>
simplify(x&*(y&*(x&*(y&*x))),S);
>
genbasis([3,2],S);
>
genbasis([4,2],S);
KacMoody algebras
Defining KacMoody 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);
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);