On which platforms does LiE run?

LiE is written in C, and can be made available on any system running UNIX or comparable operating systems, and (with a little more effort) on many other machines with a C compiler. The present version (2.2) has been successfully compiled on SGI and SUN workstations. Use of the GNU readline library makes editing and repeating commands an easy job; LiE can however easily be compiled without it on platforms with insufficient support for that library.

Support and information

A manual, which treats the mathematical functions, the language and the interpreter, comes with the package in dvi format. You can order the book describing LiE version 2.0 at CanDiensten bv, Amsterdam.

One part of the manual is devoted to the link with the mathematical theory and another chapter is devoted to examples. If you want more information beyond what the manual offers, have interesting algorithms you may want us to know, have any other helpful comments, please contact Arjeh M. Cohen , email amc@win.tue.nl or Marc A.A. van Leeuwen , email maavl@cwi.nl.

Some facts about LiE


Roughly 1 MB object code. Count on 4 MB for the whole LiE directory. LiE claims memory dynamically.

Source Code Available

LiE is a very open system: all source files come with the package! Many source files, in particuar the mathematical ones, have been documented in detail using the CWEBx system of structured software documentation.


LiE was developed by the computer algebra group at the Centre for Mathematics and Computer Science in Amsterdam. Arjeh M. Cohen, who was the leader of this group, started and coordinated the project. Marc van Leeuwen was the main author of the LiE manual. Bert Lisser was the scientific programmer; he made the language interpreter. The first memory management and set up of the entire program was done by Ron Sommeling. Bart de Smit helped coding some of the more essential mathematical routines. Bert Ruitenburg helped out with testing and generating the maximal subgroup information.

LiE's role in mathematics

LiE has been used to solve Kostant's conjecture dating from 1983 regarding subgroups of exceptional Lie groups.

Examples of built-in mathematical functions

LiE provides data of Lie theoretical nature:

> diagram( F4 )

1   2   3   4 

On-line help is available, e.g. about the function to compute Kazhdan-Lusztig polynomials:

> ?KL_poly

KL_poly(vec,vec,grp)-> pol
KL_poly(x,y,g) [x,y: Weyl word, result: polynomial]. 
Returns the Kazhdan-Lusztig  polynomial P_{x,y}.

An example:

> KL_poly( [1,2], [1,2,3,4,2,1,2,3,2,4], F4 )
In the response below you see LiE's notation for the polynomial 1+2x+x^2:
1X[0] + 2X[1] + 1X[2]

You can learn Lie theoretical concepts with LiE:

> learn highest root

Highest root This is the maximum of the set of roots with
   respect to the height partial ordering: lambda is higher
   than mu iff lambda-mu is a sum of positive roots. It is the
   highest weight of the adjoint representation.

The polynomial representing the dominant part of the character of the B3 -module with highest weight [1,1,1] is computed by:

> dom_char( all_one(3), B3 )

14X[0,0,1] + 2X[0,0,3] + 4X[0,1,1] + 8X[1,0,1] + 1X[1,1,1] +

The decomposition polynomial of the third symmetric tensor power of the A3-module with highest weight [1,1,1] is computed by:

> plethysm( [3], [1,1,1], A3 )

 4X[0,0,2] + 1X[0,0,6] +  3X[0,1,0] + 3X[0,1,4] + 8X[0,2,2] + 
 6X[0,3,0] + 1X[0,3,4] +  2X[0,4,2] + 1X[0,5,0] + 7X[1,0,3] +
11X[1,1,1] + 1X[1,1,5] +  6X[1,2,3] + 8X[1,3,1] + 1X[1,5,1] +
 4X[2,0,0] + 4X[2,0,4] + 12X[2,1,2] + 8X[2,2,0] + 1X[2,2,4] + 
 3X[2,3,2] + 2X[2,4,0] +  7X[3,0,1] + 1X[3,0,5] + 4X[3,1,3] + 
 6X[3,2,1] + 1X[3,3,3] +  4X[4,0,2] + 3X[4,1,0] + 1X[4,2,2] + 
 1X[4,3,0] + 1X[5,0,3] +  1X[5,1,1] + 1X[6,0,0]

The types of the maximal proper subgroups of E8 are:

> max_sub( E8 )


Programming example

The Coxeter matrix of a Weyl group is the matrix with entries m_ij equal to the order of the product r_i r_j of the fundamental reflections r_i and r_j. Below is a way to compute the matrix based on its definition. It illustrates the programming capacity of LiE:
cox_mat(grp g)= 
{ loc m=id(Lie_rank(g))     # start with ones on the diagonal
; for i=1 to n_rows(m)-1
    for j=i+1 to n_rows(m)  # for off-diagonal entries use ord
    do m[i,j]=ord(W_action([i,j],g)); m[j,i]=m[i,j]
; m

ord(mat m) =                # the multiplicative order of a matrix
{ loc p=m; loc i=1; loc idmat=id(n_rows(m))
; while p != idmat do p=p*m; i+=1 od
; i

Return to the LiE Home Page.

Arjeh M. Cohen

Last updated: December 19, 1996