My Littelmann path software

I have been playing with Peter Littelmann's path model of representation theory, and the following is what you can do so far. Both test programs work in the B_2 root system (though this is not assumed in the algorithms themselves - it was just the easiest to draw on screen).
This is a short explanation of the path model. If you already know how it works, skip ahead to the programs. You will only care about this stuff if you understand the representation theory of Lie groups - in particular, all the terms in the left column. The corresponding ones in the right column are the loosely corresponding concepts in the path model.

weight vector in a representation
weight of a weight vector
applying a raising/lowering operator
tensoring two weight vectors
irreducibility of a representation
path in t^*
endpoint of the path
applying a "path operator", to change the endpoint
concatenating two paths
connectedness of the colored graph of paths

The path operators

Littelmann partially defines two "path operators" for each simple root, one for raising, and one for lowering the "weight" of a path (its endpoint). I say "partially" because the operators are sometimes inapplicable - this is the analogue of a weight vector raising or lowering to the zero vector. As a consequence, the set of all paths acquires a directed graph structure for each simple root; all together this is a colored graph structure, with the simple roots as the colors.

It is easiest to define the path operators infinitesimally, and then say "take the time one flow".

To lower a path in a particular direction X, find the point on it with greatest dot product in that direction. There may be several; break ties by using the last such point, i.e. latest as traced from the origin. Past that point the path goes more in the direction -X. Take a little segment of that part and reflect it through the hyperplane perpendicular to X, leaving the rest of the path alone. The effect will be to nudge the latter part of the path in the direction X.

The subtlety in doing following the time one flow of this operation is that the hot spot can move; after a while the surgery on the path takes place near a different point. In some sense the operators are continuous but not differentiable.

To lower a path is the inverse operation. One looks for the point with the least dot product, and the ties are broken the opposite way.

If the hot spot is the endpoint of the path, the path operator is declared to be inapplicable (Littelmann says it produces "0", which is in some basically not a path). There is an annoying subtlety; the infinitesimal operators may be applicable while the finite ones (the time one flows) are not. This will be resolved in the next section.

The first test program lets one play with a path and the lowering operators. Someday soon I will implement honest raising operators!

Making a representation

In ordinary representation theory, one can recover a representation by starting with a high weight vector and hitting it with lowering operators until all further applications are the zero vector. A high weight vector is recognizable as one that raises to zero under all simple roots.

Almost the same story works in the path model, except that a dominant path is not one for which all raising operators are inapplicable, but one for which all infinitesimal raising operators are inapplicable. This is the same as its being in the positive Weyl chamber.

The second test program lets one choose an initial path (Warning: at present it trusts you to choose a dominant path) and lowers it to produce all other paths in the representation.

The theorems

Start with a dominant path with weight lambda, and close it up under the lowering operators; likewise with a dominant weight mu. Let nu be any weight. Then

The number of paths with a given endpoint nu is the dimension of the mu weight space in the representation lambda.

The colored graphs do not depend on the original path, just the weight; they are Kashiwara's crystal graphs.

Take all concatenations of a lambda-path and a mu-path. This set will also be closed under the root operators, and so form its own colored graph - but will not be connected. It has a component for each irreducible subrepresentation of the tensor product, and in each component is a unique dominant path. Such paths are necessarily the original path with endpoint lambda with a mu-path on the end, such that the concatenation is dominant.

References

These are all by Littelmann himself. As usual the ICM address is the most succinct.

A plactic algebra for semisimple Lie algebras. Adv. Math. 124 (1996), no. 2, 312--331. 17Bxx

The path model for representations of symmetrizable Kac-Moody algebras. Proceedings of the International Congress of Mathematicians, Vol. 1, 2 (Zurich, 1994), 298--308, Birkhduser, Basel, 1995. 17Bxx

Paths and root operators in representation theory. Ann. of Math. (2) 142 (1995), no. 3, 499--525.

Crystal graphs and Young tableaux. J. Algebra 175 (1995), no. 1, 65--87.

A Littlewood-Richardson rule for symmetrizable Kac-Moody algebras. Invent. Math. 116 (1994), no. 1-3, 329--346.


The first test program allows you to apply the operators yourself to a path. Commands:

  • a - left-moving lowering operator
  • l - right-moving lowering operator (see below)
  • m - down-and-right-moving lowering operator
  • b - very small down-and-right-moving lowering operator
  • space - reset to the original straight-line path
  • anything else - toggle circling the vertices.
  • Note: the right-moving operator should really be a raising operator, which means it takes the first-moving opportunity to raise rather than the last. So mathematically it's not so correct to include it.


    The source.
    The second is rather more sophisticated. It starts with a path you specify with the mouse and generates all possible paths therefrom by applying the two lowering operators. Each time, it draws the currently considered path in black, the left-shift in red, the down-and-right-shift in green. It displays the number found so far with a given endpoint. By one of Littelmann's theorems this converges to the multiplicity functions (once all paths are found).

    To specify a path, move the mouse within the positive Weyl chamber, and click on turning points, including the endpoint. Then hit space. The endpoint will be moved to a nearby weight.

    If you have it running freely, and your computer isn't quick enough to keep up with its drawing the paths, type "a" to tell it to spend more time drawing, until you can see the paths. If you want it to run faster type "A".

  • space - step through one path at a time
  • g - toggle "run freely" mode
  • a - spend more time drawing
  • A - spend less time drawing
  • mouse click - see all paths with selected weight
  • r - restart (unfortunately this is broken - you may have to do it twice)

  • The source.
    The relevant classes are Path, Arrow, and Szam. (The last is Hungarian for "number"; I needed to do my own rational arithmetic.) They are documented here.

    Coming soon: other root systems, tensor products. What else do you want? Send me mail.