Coxeter and Weyl Packages

- Introduction
- Vectors
- Root Systems
- The Database Commands
- Group Elements
- Permutation Representations
- Group Characters
- Weight Vectors
- Weyl Characters
- Using the Examples

The latest versions of these packages, along with documentation and answers to FAQs, can be downloaded from their official home page.

**Mathematical Prerequisites**

The reader should have a basic knowledge of the subject matter, including root systems (both crystallographic and non-crystallographic), reflection groups, and so on. Standard references include

- N. Bourbaki,
*Groupes et Algèbres de Lie, Chp. IV-VI*. - J. Humphreys,
*Introduction to Lie Algebras and Representation Theory*. - J. Humphreys,
*Reflection Groups and Coxeter Groups*.

**Computing Prerequisites**

The reader should also have a basic familiarity with the use of Maple.
For example, the reader should be acquainted with the essential syntax,
how to enter commands, and how to manipulate polynomials, lists, and sets.
Some of this can be learned while working through the tutorial.
We will **not** expect the reader to be able to write procedures in
Maple (nor will we explain how it is done), but the reader should realize
that procedure-writing is essential for harnessing the full power of this
or any other Maple package.

**Getting Started**

First, check that the packages have been properly installed by launching the Maple application and entering the commands

`
with(coxeter);
with(weyl);
`

The Maple response should be to list the procedures in the packages:

`
[base, cartan_matrix, char_poly, class_rep, class_size, cox_matrix,
cox_number, cprod, degrees, diagram, exponents, highest_root, index,
induce, interior_pt, iprod, irr_chars, length_gf, longest_elt, multperm,
name_of, num_refl, orbit, orbit_size, perm2word, perm_char, perm_rep,
pos_roots, presentation, rank, reduce, reflect, restrict, root_coords,
size, stab_chain, vec2fc]`

`
[co_rho, qtensor, rho, weight_coords, weight_mults, weight_sys, weights,
weyl_dim]
`

**Getting Help**

Each function in the ** coxeter** and

For example, take a look at the help file for the function
** base** in the

`
?coxeter,base
`

Similarly, the command

`
?weyl
`

retrieves a file of basic information about the ** weyl**
package, including a list of commands.

The coefficients must be rational or floating-point.

Thus for example, ** e1 - 2*e2 + (1/3)*e3** and

but

Using this data structure, vector addition and scalar multiplication are performed the same way one adds or multiplies any Maple expression. For example, try the following:

`
u:=e1 - e2; v:=e1 + e2; u + 5*v;
`

`
6 e1 + 4 e2
`

`
iprod(u,v);
`

` 0 `

`
reflect(u, e1 + 10*e2 + 100*e3);
`

`
10 e1 + e2 + 100 e3
`

- By name
- By specifying the list of simple roots (i.e., a base)
- By specifying the Cartan matrix
- By specifying the Coxeter matrix

These four formats are collectively known as **root system data
structures** throughout the documentation.

**Names**

The variable names

`A1,A2,..., B1,B2,..., C1,C2,..., D2,D3,...,
E3,E4,E5,E6,E7,E8, F4, G2, H3,H4, I2[3],I2[4],I2[5],...
`

To specify a name for a *reducible* root system, one merely forms
a monomial out of irreducible names. For example, the expression

`
A1^2 * C4
`

**Bases**

A base (i.e., the set of simple roots) for a root system can be specified by means of a list of vectors. For example, the expression

`
[ e2 - e1, e3 - e2 ]
`

`
base(A2*C3); base(H3);
`

`
[e2 - e1, e3 - e2, 2 e4, e5 - e4, e6 - e5]
[2 e1, - 1.618033989 e1 + .618033989 e2 - e3, 2 e3]
`

Conversely, given a list of simple roots for some root system, the command
** name_of** can be used to produce the (standard) name of
this root system. For example, try

`
S:=base(E5);
name_of(S);
`

` D5 `

`
diagram(D5); diagram(E5);
`

2 | 1---3---4---5 2 | 1---3---4---5

**Cartan Matrices**

A crystallographic root system can also be specified by means of its
Cartan matrix. Recall that if ** r_1,r_2,...** are the simple
roots, then the

`
iprod(r_i , (r_j) ^{v}),
`

`
cm:=cartan_matrix(F4); base(cm);
`

[ 2 -1 0 0 ] [ ] [ -1 2 -1 0 ] cm := [ ] [ 0 -2 2 -1 ] [ ] [ 0 0 -1 2 ] [e3 - e2, e2 - e1, e1, - 1/2 e1 - 1/2 e2 - 1/2 e3 + 1/2 e4]

`
S:=base(E5);
cm:=cartan_matrix(S);
name_of(cm);
`

` D5 `

A fourth way to specify a root system is by means of its Coxeter matrix.
If ** s_1,s_2,...** are the simple reflections, then the

This is more useful as a way of specifying the reflection group of a root
system, rather than the root system itself, since the Coxeter matrix carries
no information that allows one to distinguish root systems that differ only
in the respective lengths of their roots. If you specify a Coxeter matrix
that has more than one crystallographic realization corresponding to it,
some computations may require the ** coxeter** package to make
a choice.

For example, consider the following:

`
cx:=cox_matrix(C4);
name_of(cx), base(cx);
`

[ 1 4 2 2 ] [ ] [ 4 1 3 2 ] cx := [ ] [ 2 3 1 3 ] [ ] [ 2 2 3 1 ] B4, [e1, e2 - e1, e3 - e2, e4 - e3]

Here the package chose a realization isomorphic to ** B4**,
rather than

As the above examples show, the procedures ** name_of**,

The size of a reflection group:

`
size(E8);
`

` 696729600 `

`
cox_number(H4);
`

` 30 `

`
degrees(E7);
`

`
[2, 6, 8, 10, 12, 14, 18]
`

`
exponents(D6);
`

`
[1, 3, 5, 5, 7, 9]
`

`
index(E6);
`

` 3 `

`
length_gf(A3,q); sort(");
`

The number of reflections, or equivalently, the number of positive roots:6 5 4 3 2 q + 3 q + 5 q + 6 q + 5 q + 3 q + 1

`
num_refl(B5);
`

` 25 `

`
pos_roots(D3);
`

`
[e1 + e2, e2 - e1, e3 - e2, e1 + e3, - e1 + e3, e3 + e2]
`

`
highest_root(F4);
`

`
e3 + e4
`

`
r:=highest_root(E8);
root_coords(r,E8);
`

`
[2, 3, 4, 6, 5, 4, 3, 2]
`

`
map(root_coords, pos_roots(F4), F4);
`

The element ** s_{i_1} ... s_{i_k}**
of

`
[i_1, ..., i_k].
`

`
w:=[1,2,3,2,1,2,3]; reduce(w,A3);
`

`
[2, 1, 3, 2, 1]
`

`
reduce(x, R) = reduce(y, R).
`

`
w1:=[1,2,3,2,1]; w2:=[2,1,2,3];
w:=reduce([op(w1),op(w2)], B3);
invw:=[seq( w[-i], i=-nops(w)..-1)];
`

`
w := [1, 2, 1, 2, 3, 2, 1]
invw := [1, 2, 3, 2, 1, 2, 1]
`

The longest element of ** W(R)** can be obtained as follows:

`
longest_elt(D4);
`

`
[1, 2, 3, 1, 2, 3, 4, 3, 1, 2, 3, 4]
`

To obtain a list of canonical representatives of the conjugacy classes of
** W(R)**, and their sizes, try the following:

`
class_rep(H3);
class_size(H3);
`

`
[[], [1, 2], [1], [1, 2, 3], [2, 3], [1, 2, 1, 2, 3],
[1, 2, 1, 2], [1, 3], [1, 2, 1, 2, 3, 2, 1, 2, 3],
[1, 2, 1, 2, 1, 3, 2, 1, 2, 1, 3, 2, 1, 2, 3]]
[1, 12, 15, 12, 20, 20, 12, 15, 12, 1]
`

`
w0:=longest_elt(E6);
class_rep(w0,E6), class_size(w0,E6);
`

`
[2, 3, 4, 2, 3, 4, 5, 4, 2, 3, 4, 5], 45
`

The easiest way to determine how a given group element ** w**
acts on a vector

`
S:=base(F4);
reflect(S[2],S[3],S[1],S[2],e3);
`

`
1/2 e1 - 1/2 e2 + 1/2 e3 + 1/2 e4
`

`
w:=[2,3,1,2];
reflect(seq(S[i],i=w),e3);
`

Recall that every ** W(R)**-orbit has a unique vector in the
(closure of the) fundamental chamber. The command

`
vec2fc(e3,F4);
`

` e4 `

`
vec2fc(e3,F4,'w'), w;
`

` e4, [1, 2, 3, 2, 1] `

The command ** interior_pt** can be used to produce a vector in
the interior of the fundamental chamber. For example, try

`
v0:=interior_pt(A4);
vec2fc(-v0, A4, 'w0'); w0;
`

`
[1, 2, 1, 3, 2, 1, 4, 3, 2, 1]
`

**Exercise 2:** Find a reduced expression for the reflection
corresponding to the highest root of ** E6**.

The command for generating a permutation representation is
** perm_rep**. In particular, if

`
pg:=perm_rep(H3);
`

`
pg := permgroup(12, {s1 = [[3,4], [5,6], [7,8], [9,10]],
s2 = [[2,3], [4,5], [8,9], [10,11]],
s3 = [[1,2], [5,7], [6,8], [11,12]]})
`

To determine the permutation corresponding to a given element of
** W(R)**, use

`
pglist:=op(2,pg);
pi:=multperm([1,2,3,2], pglist);
`

`
pi := [[1, 3, 7, 8, 4], [5, 9, 12, 10, 6]]
`

`
perm2word(pi, pg);
`

`
[1, 2, 3, 2]
`

`
S:=base(H3); S:=[S[2],S[3],S[1]];
pg:=perm_rep(S, export);
`

s1:=(2,3)(5,7)(6,8)(9,10)(11,13)(12,14)(15,16)(18,19); s2:=(3,4)(5,6)(7,9)(8,10)(11,12)(13,15)(14,16)(17,18); s3:=(1,2)(3,5)(4,6)(8,11)(10,12)(14,17)(16,18)(19,20); G:=Group(s1,s2,s3); G.name:="H3";

This can be read directly into a **GAP** session.

`
ct:=irr_chars(D4);
`

ct := [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [3, 1, -1, 0, -1, 3, 1, 1, 3, -1, 0, -1, -1], [2, 0, 2, -1, 0, 2, 0, 0, 2, 2, -1, 2, 0], [3, -1, -1, 0, 1, 3, -1, -1, 3, -1, 0, -1, 1], [1, -1, 1, 1, -1, 1, -1, -1, 1, 1, 1, 1, -1], [4, 2, 0, 1, 0, 0, -2, 0, -4, 0, -1, 0, 0], [8, 0, 0, -1, 0, 0, 0, 0, -8, 0, 1, 0, 0], [4, -2, 0, 1, 0, 0, 2, 0, -4, 0, -1, 0, 0], [3, 1, 3, 0, 1, -1, 1, -1, 3, -1, 0, -1, -1], [3, 1, -1, 0, -1, -1, 1, -1, 3, -1, 0, 3, 1], [6, 0, -2, 0, 0, -2, 0, 0, 6, 2, 0, -2, 0], [3, -1, 3, 0, -1, -1, -1, 1, 3, -1, 0, -1, 1], [3, -1, -1, 0, 1, -1, -1, 1, 3, -1, 0, 3, -1]]

The output is a list-of-lists. The ** i**-th list is
the list of values of an irreducible character on the conjugacy
classes of the group, following the same order used by the function

Suppose we want to compute the values of the irreducible characters
on the group element ** w=[1,2,3,4,1,2,3,4]**. We can use
the

`
w:=class_rep([1,2,3,4,1,2,3,4], D4);
member(w, class_rep(D4), 'j');
j, ct[3][j];
`

`
4, -1
`

To compute the inner product of two characters, use ** cprod**
(

`
cprod(ct[1], ct[2], D4);
`

` 0 `

`
map(cprod, ct, ct[1], D4);
`

`
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
`

To induce a character up to ** W(R)** from a reflection
subgroup, use the

Let's start with an example involving ** perm_char**.
To specify a parabolic subgroup, all we need to do is choose a sublist
of

`
chi:=perm_char([2,3,4], B4);
map(cprod, irr_chars(B4), chi, B4);
`

`
chi := [16, 8, 4, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0]
`

To induce a character from a reflection subgroup that is not parabolic,
we have to specify a set of roots that form a base for the corresponding
root subsystem. For example, if we delete the first simple root of
** F4** and replace it with the negative of the highest root,
we obtain a simple system for

`
r:=highest_root(F4);
S:=base(F4); J:=[-r,S[2],S[3],S[4]];
chi:=perm_char(J, F4);
`

`
[3, 1, 3, 1, 0, 0, 3, 0, 1, 1, 3, 0, 1, 3, 1, 3, 0, 1, 0, 3, 1, 3, 1, 0, 3]
`

`
restrict(chi, [1,2,3], F4);
`

`
[3, 1, 0, 3, 1, 3, 1, 3, 1, 0]
`

Now consider an example involving induction of a non-trivial character.

For any group element ** w**, the function

`
cp:=[seq(char_poly(w, A3, -q), w=class_rep(A3))];
chi:=[seq(coeff(f,q), f=cp)];
induce(chi, [2,3,4], D4);
`

`
[24, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, -4, -2]
`

[

From now on, *all root systems are assumed to be crystallographic*.

A vector ** u** belongs to the weight lattice of the root
system

** iprod(u,r^{v})** is an integer

** iprod(w_i,(r_j)^{v}) = 1**
(if

The easiest way to work with weight vectors in the
** weyl** package is to use the

`
w:=weights(F4);
v:=2*w[1]+w[3];
`

`
w := [e4, 1/2 e1 + 1/2 e2 + 1/2 e3 + 3/2 e4, e2 + e3 + 2 e4, e3 + e4]
v := e2 + e3 + 4 e4
`

`
weight_coords(v, F4);
weight_coords(highest_root(F4), F4);
`

`
[2, 0, 1, 0]
[0, 0, 0, 1]
`

`
weight_coords(rho(B4), B4);
r0:=co_rho(B4);
map(iprod, pos_roots(B4), r0);
`

`
[1, 1, 1, 1]
r0 := e1 + 2 e2 + 3 e3 + 4 e4
[1, 1, 1, 1, 2, 3, 2, 2, 3, 4, 3, 4, 5, 5, 6, 7]
`

`
w:=weights(B4);
v:=2*w[1]+w[2];
weyl_dim(v, B4);
`

` 4158 `

`
weyl_dim(v, B4, q);
`

7 9 2 11 8 10 (1 - q ) (1 - q ) (1 - q ) (1 - q ) (1 - q ) ------------------------------------------------ 19 3 2 2 5 4 q (1 - q ) (1 - q) (1 - q ) (1 - q ) (1 - q )

**Weight Multiplicity**

The decomposition of a representation relative to a maximal torus
(maximal abelian subgroup/subalgebra) is the so called weight-space
decomposition. The weight spaces are indexed by weight vectors, and
the dimensions of the weight spaces (i.e., weight multiplicities)
are invariant under the action of the Weyl group ** W(R)**.
Thus the weight multiplicities of a given representation can be inferred
from the multiplicities of the dominant weights.

Consider the irreducible representation ** V** indexed by
the dominant weight

The command ** weight_sys** can be used to generate the
set of dominant weights that occur with positive multiplicity in the
irreducible representation indexed by

`
ws:=weight_sys(v, B4);
map(weight_coords, ws, B4);
`

`
ws := [e1 + 2 e2 + 2 e3 + 2 e4, 2 e2 + 2 e3 + 2 e4, e1 + e2 + 2 e3 + 2 e4,
e2 + 2 e3 + 2 e4, e1 + e2 + e3 + 2 e4, e2 + e3 + 2 e4, 2 e3 + 2 e4,
e1 + e2 + e3 + e4, e3 + 2 e4, e2 + e3 + e4, 2 e4, e3 + e4, e4, 0]
[[2, 1, 0, 0], [0, 2, 0, 0], [2, 0, 1, 0], [0, 1, 1, 0],
[2, 0, 0, 1], [0, 1, 0, 1], [0, 0, 2, 0], [2, 0, 0, 0],
[0, 0, 1, 1], [0, 1, 0, 0], [0, 0, 0, 2], [0, 0, 1, 0],
[0, 0, 0, 1], [0, 0, 0, 0]]
`

`
weight_mults(v, B4);
`

`
M[2, 1, 0, 0] + M[0, 2, 0, 0] + 2 M[2, 0, 1, 0] +
3 M[0, 1, 1, 0] + 6 M[2, 0, 0, 1] + 3 M[0, 0, 2, 0] +
7 M[0, 1, 0, 1] + 10 M[0, 0, 1, 1] + 15 M[2, 0, 0, 0] +
21 M[0, 1, 0, 0] + 12 M[0, 0, 0, 2] + 26 M[0, 0, 1, 0] +
37 M[0, 0, 0, 1] + 46 M[0, 0, 0, 0]
`

The user should not assign values to the variable
** M** when computing weight multiplicities.

It is also possible to compute the dimension of a single weight space:

`
weight_mults(v, 2*w[1]+w[4], B4);
`

` 6 `

The command ** qtensor** uses a quick-and-dirty algorithm that
attempts to decompose the tensor product of two irreducible representations
into a sum of irreducibles. It tends to be most effective for the
exceptional groups.

`
w:=weights(F4);
qtensor(w[2], w[3], F4);
`

`
X[0, 1, 1, 0] + X[1, 1, 0, 1] + X[2, 1, 0, 0] +
X[0, 2, 0, 0] + X[1, 0, 1, 0] + 2 X[0, 1, 0, 1] +
X[1, 0, 0, 2] + X[2, 0, 0, 1] + 2 X[1, 1, 0, 0] +
X[0, 0, 1, 0] + X[3, 0, 0, 0] + 2 X[1, 0, 0, 1] +
X[0, 1, 0, 0] + X[2, 0, 0, 0] + X[1, 0, 0, 0]
`

The user should not assign values to the variable
** X** when using

The algorithm tends to be least effective for the classical
groups, especially ** SL_{n}**. (On the other hand,
there are very good algorithms for tensor product decompositions
in type

`
w:=weights(A4);
u:=w[1]+w[2]; v:=w[2]+w[3];
qtensor(u, v, A4);
`

` FAIL `

`
qtensor(u, v, A4, c);
`

`
X[1, 2, 1, 0] + X[2, 0, 2, 0] + (1 - c7) X[0, 1, 2, 0] +
(1 + c7) X[2, 1, 0, 1] + (1 - c7) X[0, 2, 0, 1] +
2 X[1, 0, 1, 1] + c7 X[3, 0, 0, 0] +
(1 + c7) X[1, 1, 0, 0] + X[0, 0, 0, 2] + X[0, 0, 1, 0]
`

- generating the Bruhat ordering and weak ordering of a Coxeter group,
- computing the q-analogue of weight multiplicity,
- efficiently traversing the elements of a Coxeter group,
- generating shortest (left or double) coset representatives,

and many others. The examples are located in a subdirectory of the directory where the packages have been installed. The installation directory can be easily determined by entering the following Maple command:

`
HomeLib;
`

At this point you can use the "Open File" feature of your Web browser
to navigate your way to this directory. From there, go to the subdirectory
** coxeter**. There, you will find an

Each file contains extensive documentation, along with Maple code that needs to be explicit read during a Maple session. We illustrate this with the weak_order example. (This particular example requires that the posets package has been previously installed.)

First, we need to read the code into our Maple session:

`
read ````.HomeLib.```/coxeter/examples/weak_order``;

All of the above quote marks are **left** quote marks (**`**).

In the following, we are going to use the ** plot_poset**
function of the

`
with(posets,plot_poset);
P:=weak_order(B3,[red,blue,purple],'CG');
plot_poset(P, ecolor=CG);
`

Copyright 1998 by John R. Stembridge, University of Michigan, Ann Arbor MI 48109. Last modified Mon Jun 29 10:38:31 EDT 1998