# A Tutorial Introduction to the Coxeter and Weyl Packages

## Introduction

This document provides a step-by-step introduction to the use of Version 2.1 of coxeter and weyl, a pair of Maple packages for working with root systems, finite Coxeter groups and Weyl characters.

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 weyl packages has a help file that explains the purpose and syntax of the command and provides a few small examples.

For example, take a look at the help file for the function base in the coxeter package by entering the command

?coxeter,base

Similarly, the command

?weyl

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

## Vectors

In coxeter and weyl, the variable names e1, e2, e3,... are reserved for use as an orthonormal basis for Euclidean space. Vectors are then formed by taking linear combinations of these basis elements. (Note: This should not be confused with the vector data structure used in Maple's linalg package.)

The coefficients must be rational or floating-point.

Thus for example, e1 - 2*e2 + (1/3)*e3 and 1.1*e1 - e3 are valid vectors,
but a*e1 + sqrt(5)*e2 is not.

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

The function iprod in the coxeter package computes the inner product of two vectors:

iprod(u,v);

0

To compute the result of reflecting a vector v through the hyperplane orthogonal to the nonzero vector r, use the command reflect(r,v). For example,

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

10 e1 + e2 + 100 e3

## Root Systems

Many of the commands in coxeter and weyl involve the specification of a root system. All of these commands allow the specification to be given in any of four ways:
1. By name
2. By specifying the list of simple roots (i.e., a base)
3. By specifying the Cartan matrix
4. 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,I2,I2,...

are reserved for use as names for the irreducible root systems. The alert reader will notice that there are some nonstandard names in this list (B1 is an alias for A1, for example), and some of these non-standard names refer to root systems that aren't irreducible. These are provided merely as a convenience for the user; Maple never uses the nonstandard names internally.

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

refers to a root system of rank 6 formed by taking the orthogonal direct sum of two copies of A1 and one copy of 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 ]

is a base for the root system A2. The command base can be used to produce a list of simple roots for any root system. For example, try

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]

Notice that floating-point coordinates are used for the non-crystallographic root system H3.

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

In this case, the simple roots of E5 occur in a different in order than those of the (isomorphic) root system D5. We can compare how the simple roots in base(D5) and base(E5) are ordered by displaying their Dynkin diagrams:

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 (i,j) entry of the Cartan matrix is

iprod(r_i , (r_j)v),

where rv = 2*r/iprod(r,r) denotes the co-root corresponding to r. For example, try the following:

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

Coxeter Matrices

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 (i,j) entry of the Coxeter matrix is the order of the linear transformation s_i * s_j.

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 C4.

As the above examples show, the procedures name_of, base, cartan_matrix, and cox_matrix allow the user to convert among any of the four types of root system data structures.

## The Database Commands

There are several commands in the coxeter package that retrieve basic data about a root system or reflection group, such as one finds in the appendices of Bourbaki. For example,

The size of a reflection group:

size(E8);

696729600

The order of a Coxeter element (the product of the simple reflections, taken in any order), also known as the Coxeter number:

cox_number(H4);

30

The degrees of the basic polynomial invariants of a reflection group:

degrees(E7);

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

The exponents of a root system. These are related to the eigenvalues of the Coxeter element, and can be obtained by decreasing the degrees by 1:

exponents(D6);

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

The index of the root lattice in the weight lattice (also known as the index of connection):

index(E6);

3

The length generating function (or Poincaré series) for a reflection group. (That is, the sum of ql(w) over all elements w of the reflection group, where l(.) denotes the length function.):

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

```
6      5      4      3      2
q  + 3 q  + 5 q  + 6 q  + 5 q  + 3 q + 1
```

The number of reflections, or equivalently, the number of positive roots:

num_refl(B5);

25

The positive roots:

pos_roots(D3);

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

The highest root in an irreducible crystallographic root system:

highest_root(F4);

e3 + e4

The coordinates of a vector with respect to the simple roots can be computed using the root_coords command. For example, the coordinates of the highest root:

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

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

Using Maple's map command, we can easily compute the simple root coordinates of all the positive roots. Try

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

## Group Elements

Let s_1,s_2,... denote the reflections corresponding to some (ordered) list of simple roots for a root system R, and let W(R) denote the reflection group they generate.

The element si_1 ... si_k of W(R) is represented in the coxeter package by the list

[i_1, ..., i_k].

In particular, the identity element is represented as [ ]. To obtain a reduced expression for a group element, use the reduce function:

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

[2, 1, 3, 2, 1]

The expression returned is first in lexicographic order among all reduced expressions for w, so two group elements x and y are equal if and only if

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

Multiplication and inversion in the group is best explained by a pair of examples:

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]

Exercise 1: Does w=[1,2,4,3,2,1,3,4] represent an involution in W(F4)?

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]

Conjugacy Classes

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, 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]

To determine the size and canonical representative of the conjugacy class containing a particular element w, use the calling sequences class_rep(w,R) and class_size(w,R):

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 Reflection Representation

The easiest way to determine how a given group element w acts on a vector v in the reflection representation is based on the calling sequence reflect(r_1,r_2,...,v). This computes the result of applying a sequence of reflections to v, working from right to left. For example,

S:=base(F4);
reflect(S,S,S,S,e3);

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

Try it also with Maple's seq command:

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 ("map this vector to the fundamental chamber") can be used to find the dominant vector in the orbit of a given vector.

vec2fc(e3,F4);

e4

With an optional third argument, we can determine the shortest element of W(R) that maps the dominant vector back to the original vector:

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

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

We have to enclose w in single quotes (') in order to prevent Maple from getting confused about previously assigned values for w.

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]

This provides another way, besides the command longest_elt, to generate a reduced expression for the longest element of W(R).

## Permutation Representations

The coxeter package also has facilities for generating permutation representations of Coxeter groups. These representations can then be used in conjunction with Maple's group package, or exported to GAP.

The command for generating a permutation representation is perm_rep. In particular, if R is any root system data structure, perm_rep(R) will generate the permutation representation of W(R) induced by the action on cosets of the parabolic subgroup obtained by deleting the last simple root listed in base(R). This representation is faithful if and only if R is irreducible. Try

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]]})

The permgroup(...) expression is Maple's data structure for representing permutation groups. In this case, it is describing a permutation group of degree 12 with generators s1,s2,s3. The cycle factorization of s1 is [[3,4],[5,6],[7,8],[9,10]], and so on. For more information, see the help for group.

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

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

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

Conversely, to recover the group element corresponding to a permutation, use perm2word:

perm2word(pi, pg);

[1, 2, 3, 2]

By adding export as a second argument to the perm_rep command, we can generate a permutation representation in the format used by GAP. This time, we will reorder the simple roots so that we generate the permutation representation of W(H3) acting on cosets of W(A2):

S:=base(H3); S:=[S,S,S];
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.

## Group Characters

The coxeter package knows how to generate the character table of every finite Coxeter group.

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 class_rep (see the section on Group Elements). In particular, the identity element is always first, so the first entry for each character is its degree.

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 class_rep function, together with Maple's member command to tell us the conjugacy class to which this element belongs.

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

4, -1

Thus [1,2,3,4,1,2,3,4] belongs to the 4th conjugacy class of W(D4), and the value of the 3rd character on this class is -1.

To compute the inner product of two characters, use cprod (Character inner PRODuct):

cprod(ct, ct, D4);

0

Using Maple's map command, it is easy to compute the multiplicities of the irreducible characters in any class function on W(R):

map(cprod, ct, ct, D4);

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

Induction/Restriction

To induce a character up to W(R) from a reflection subgroup, use the induce command. Also available is perm_char for the special case involving induction of the trivial character.

Let's start with an example involving perm_char. To specify a parabolic subgroup, all we need to do is choose a sublist of [1,...,n] indicating the generators of the subgroup, following the indexing of diagram(R).

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]

Thus the action of W(B4) on W(B4)/W(A3) has 5 irreducible constituents.

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 B4 in F4.

r:=highest_root(F4);
S:=base(F4); J:=[-r,S,S,S];
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]

It is easy to restrict a character to any reflection subgroup:

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

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

Here we have restricted chi to the parabolic subgroup of type C3.

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

For any group element w, the function char_poly(w, R, q) computes det(1 - q*w) in the reflection representation of W(R). In particular, the coefficient of q in char_poly(w, R, -q) is the character of the reflection representation.

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]

Exercise 3: Determine the number of double cosets of the form W(H3)\W(H4)/W(A3).
[Hint: This amounts to a computation involving permutation characters.]

## Weight Vectors

We now turn to the contents of the weyl package.

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

A vector u belongs to the weight lattice of the root system R if

iprod(u,rv)   is an integer

for all roots r (or equivalently, all simple roots). If the simple roots are r_1,r_2,..., then the fundamental weights w_1,w_2,... may be defined by the condition

iprod(w_i,(r_j)v) = 1 (if i=j),  0 (otherwise).

The weight lattice is generated by the fundamental weights, and the dominant weights are those in the nonnegative (integral) span of the fundamental weights.

The easiest way to work with weight vectors in the weyl package is to use the weights command to produce the list of fundamental weights.

w:=weights(F4);
v:=2*w+w;

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

To determine the coordinates of a vector with respect to the fundamental weights (useful for confirming membership in the weight lattice, for example), use weight_coords:

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

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

Also available are functions for producing the frequently-occurring vectors rho and co_rho (i.e., half of the sum of the positive roots and positive co-roots, respectively). The former is also the sum of the fundamental weights.

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]

The inner product of co_rho(R) with a root r is its height; i.e., the sum of root_coords(r).

## Weyl Characters

The (finite dimensional) irreducible representations of a complex Lie group or Lie algebra with root system R are indexed by the dominant weights. The dimensions of these representations can be computed by means of the Weyl dimension formula:

w:=weights(B4);
v:=2*w+w;
weyl_dim(v, B4);

4158

With a third argument qweyl_dim computes the principal specialization of the Weyl character of the corresponding representation:

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 v. It turns out that the dominant weights u that occur with positive multiplicity in V are those for which v >= u; i.e., whenever v - u is in the nonnegative integral span of the positive roots.

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 v:

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]]

To compute weight multiplicities, use weight_mults:

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 subexpression 6*M[2,0,0,1] serves as a place-holder indicating that the dominant weight 2*w_1 + w_4 occurs with multiplicity 6.

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+w, B4);

6

Tensor Products

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, w, 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 subexpression 2*X[0,1,0,1] serves as a place-holder indicating that the irreducible representation indexed by the dominant weight w_2 + w_4 occurs with multiplicity 2.

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

The algorithm tends to be least effective for the classical groups, especially SLn. (On the other hand, there are very good algorithms for tensor product decompositions in type A. In particular, the SF package is quite good at this.)

w:=weights(A4);
u:=w+w; v:=w+w;
qtensor(u, v, A4);

FAIL

Even when the algorithm fails, it is possible gain partial information about the tensor product decomposition by adding a dummy variable as a fourth argument.

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]

In this case, we see a single undetermined coefficient c7 appearing in the answer. Taking into account that tensor product multiplicities must be nonnegative integers, we see that there only two possible values for c7: either 0 or 1.

## Using the Examples

In addition to the commands in coxeter and weyl, there is also a directory of files containing several examples that illustrate advanced usage of the packages. Included among the examples are procedures for
• 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 examples subdirectory.

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: