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
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.
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
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
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, trybase(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
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 MatricesA 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 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 + 1The 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. Trymap(root_coords, pos_roots(F4), F4);
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 ifreduce(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]
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 ClassesTo 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 Reflection RepresentationThe 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[2],S[3],S[1],S[2],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).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 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]]})
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[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 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[3][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[1], ct[2], 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[1], D4);
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Induction/RestrictionTo 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]
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[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]
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).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[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
With a third argument q, weyl_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]]
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
Tensor ProductsThe 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 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[1]+w[2]; v:=w[2]+w[3];
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]
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:
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 posets package to display the Cayley graph of the reflection group W(B3):
with(posets,plot_poset);
P:=weak_order(B3,[red,blue,purple],'CG');
plot_poset(P, ecolor=CG);