weyl_dim - dimension of an irreducible representation
FUNCTION: base - simple roots of a root system
co_base - simple co-roots of a root system
CALLING SEQUENCE: base(R);
co_base(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
base(R) returns a list of simple roots for R, expressed as linear
combinations of the standard orthonormal basis e1,e2,e3,...
If R is not crystallographic, floating-point coordinates are used.
If R is a root system name, the list of roots is ordered canonically in a
way that does not vary with each Maple session. The base vectors for each
irreducible component of R are listed consecutively, sorted first by
series name (A,B,...,I), and then by rank within each series (so A2
precedes A3, A10 precedes B2,...). The diagram function can be used to
display the ordering of base vectors within a given irreducible component.
If R is a Coxeter or Cartan matrix, the ordering of the rows and columns
of the matrix dictates the ordering of the simple roots.
If R is a list, it is assumed that R itself is a list of simple roots and
base(R) simply returns R.
co_base(R) returns the list of co-roots corresponding to the simple roots
listed by base(R). The co-root corresponding to root r is 2*r/iprod(r,r).
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
S:=base(A2*B2); yields [e2-e1, e3-e2, e4, e5-e4]
base(S); yields [e2-e1, e3-e2, e4, e5-e4]
co_base(S); yields [e2-e1, e3-e2, 2*e4, e5-e4]
base(I2[5]); yields [e1, -.8090169945*e1+.5877852520*e2]
CoxMat:=array([[1,3,2],[3,1,4],[2,4,1]]);
base(CoxMat); yields [e3-e2, e2-e1, e1]
SEE ALSO: cartan_matrix, cox_matrix, diagram, iprod, name_of, structure
FUNCTION: cartan_matrix - Cartan matrix of a crystallographic root system
CALLING SEQUENCE: cartan_matrix(R);
PARAMETERS: R = a crystallographic root system data structure
SYNOPSIS:
The Cartan matrix of a crystallographic root system with simple roots
[r_1,...,r_n] is the n x n integer matrix whose (i,j)-entry is
2 * iprod(r_i,r_j) / iprod(r_j,r_j).
An error is generated if these quantities do not evaluate to integers.
The Cartan "matrix" of the empty root system is the empty list [].
If R is a Coxeter matrix, cartan_matrix(R) returns the Cartan matrix for
some crystallographic root system with Coxeter matrix R, if one exists.
If R is a matrix of integers whose (1,1)-entry is 2, it is assumed that
R is itself a Cartan matrix and cartan_matrix(R) returns R.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
cartan_matrix(F4)[3,2]; yields -2
a:=cartan_matrix([e1-e2,2*e2]); yields array([[2,-1],[-2,2]])
cartan_matrix(a); yields array([[2,-1],[-2,2]])
m:=array([[1,2,3],[2,1,3],[3,3,1]]);
cartan_matrix(m)[1,3]; yields -1
SEE ALSO: base, cox_matrix, iprod, diagram, name_of, structure
FUNCTION: char_poly - characteristic polynomial of a group element
CALLING SEQUENCE: char_poly(w,R);
char_poly(w,R,t);
PARAMETERS: R = a root system data structure
w = a list of integers representing a member of W(R)
t = a variable or expression (optional)
SYNOPSIS:
If R is a root system of rank n, members of the Coxeter group W(R) are
represented as lists of integers in the range 1..n. The group element
corresponding to w = [i_1,...,i_l] is the product of the generators
indexed by i_1,...,i_l. The indexing follows base(R).
If w is such a group element, char_poly(w,R,t) computes the determinant
of 1 - t*w, as a linear transformation of the space spanned by base(R).
If the third argument is omitted, q is the default.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
char_poly([1,3,2,3],B3); yields 1-q+q^2-q^3
char_poly([1,2,3,4],D4,1); yields 4
f:=char_poly([1,2,3,2],H3,z);
evalf(f,3); yields 1.-1.62*z+1.62*z^2-1.00*z^3
SEE ALSO: base, rank, reflect, structure
FUNCTION: class_rep - determine conjugacy class representatives
CALLING SEQUENCE: class_rep(w,R);
class_rep(R);
PARAMETERS: R = a root system data structure
w = a list of integers representing an element of W(R)
SYNOPSIS:
If R is a root system of rank n, elements of the Coxeter group W(R) are
represented as lists of integers in the range 1..n. The group element
corresponding to w = [i_1,...,i_l] is the product of the generators
indexed by i_1,...,i_l. The indexing follows base(R).
class_rep(w,R) produces a canonical representative of the conjugacy class
of W(R) that contains w. Two elements w1 and w2 of W(R) are conjugate if
and only if class_rep(w1,R) = class_rep(w2,R).
class_rep(R) returns the list of canonical representatives for every
conjugacy class of W(R). The ordering of the list is consistent with the
ordering used by the functions class_size, cprod, induce, irr_chars,
perm_char, and restrict. The identity element [] is always first.
The conjugacy class representatives for the exceptional groups E-F-H are
read from prestored lists in the coxeter/lib subdirectory. The lists for
the remaining irreducible cases are generated "on demand".
The algorithm for finding the representative for a particular w proceeds
by breaking R into irreducible components, and then separately determining
the canonical representative for each component of w. For types I2 and G2,
brute force is used. For the groups of type H3 and H4, it uses the
characteristic polynomial of w. For all other groups, it uses a faithful
representation of W(R) as a subgroup of a hyperoctahedral group G with the
property that distinct conjugacy classes of W(R) map to distinct conjugacy
classes of G. Some extra parity tricks are also necessary to separate
certain conjugacy classes of type D.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
class_rep([1,2,3,4,3,4,1],A2^2); yields [1,3,4]
w0:=longest_elt(D4);
class_rep(w0,D4); yields [1,2,3,1,2,3,4,3,1,2,3,4]
class_rep(I2[5]); yields [[],[1],[1,2],[1,2,1,2]]
SEE ALSO: base, class_size, char_poly, cprod, perm_char, induce, irr_chars,
restrict, structure
FUNCTION: class_size - determine sizes of conjugacy classes
CALLING SEQUENCE: class_size(w,R);
class_size(R);
PARAMETERS: R = a root system data structure
w = a list of integers representing an element of W(R)
SYNOPSIS:
If R is a root system of rank n, elements of the Coxeter group W(R) are
represented as lists of integers in the range 1..n. The group element
corresponding to w = [i_1,...,i_l] is the product of the generators
indexed by i_1,...,i_l. The indexing follows base(R).
class_size(w,R) returns the size of the conjugacy class of w in W(R).
class_size(R) returns a list of the sizes of all W(R)-conjugacy classes,
following the same ordering used by the functions class_rep, cprod,
induce, irr_chars, perm_char, and restrict.
The conjugacy class sizes for the exceptional groups E-F-H are read
from prestored lists in the coxeter/lib subdirectory. The lists for the
remaining irreducible cases are generated "on demand".
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
class_size([4,3,2,1,2,1],H4); yields 720
w0:=longest_elt(A2*G2);
class_size(w0,A2*G2); yields 3
class_size(C3); yields [1,6,8,3,6,3,6,1,6,8]
SEE ALSO: base, class_rep, cprod, perm_char, induce, irr_chars,
restrict, structure
FUNCTION: cox_matrix - Coxeter matrix of a root system or Coxeter group
CALLING SEQUENCE: cox_matrix(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
The Coxeter matrix of R is the n x n matrix whose (i,j) entry is the
order of s_i * s_j in W(R), where [s_1,...,s_n] denote the simple
reflections. Equivalently, the (i,j)-entry is m if (1-1/m)*Pi is the
angle between the i-th and j-th simple roots of R.
If R is a matrix whose (1,1) entry is 1, it is assumed that R is itself
a Coxeter matrix and cox_matrix(R) returns R. Any other matrix is assumed
to be the Cartan matrix of a (not necessarily finite) root system.
The Coxeter "matrix" of the empty root system is the empty list [].
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
cox_matrix(H4)[1,2]; yields 5
m:=cox_matrix([e1-e3,-e1-e2+2*e3]);
yields array([[1,6],[6,1]])
cox_matrix(m); yields array([[1,6],[6,1]])
m:=array([[2,-2,0],[-1,2,-1],[0,-2,2]]);
cox_matrix(m); yields array([[1,4,2],[4,1,4],[2,4,1]])
SEE ALSO: base, cartan_matrix, diagram, name_of, presentation, structure
FUNCTION: cox_number - Coxeter number of a Coxeter group
CALLING SEQUENCE: cox_number(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
A Coxeter element of a Coxeter group W(R) is obtained by taking the
product of the simple reflections of W(R), in any order. The Coxeter
number is the order of any Coxeter element.
cox_number(R) computes the Coxeter number by using the fact that for
irreducible R, the Coxeter number is the largest member of degrees(R).
The Coxeter number is also expressible as 2*num_refl(R)/rank(R), again
assuming R is irreducible.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
cox_number(E6); yields 12
cox_number(A3^2*A1); yields 4
SEE ALSO: degrees, num_refl, rank, structure
FUNCTION: cprod - inner product of characters or class functions
CALLING SEQUENCE: cprod(f,g,R);
PARAMETERS: R = a root system data structure
f,g = lists representing class functions on W(R)
SYNOPSIS:
A character or class function on W(R) is represented as a list of values
[a_1,...,a_l], where a_i is the function value on an element in the i-th
conjugacy class. A consistent ordering of the conjugacy classes is used
by each of the functions class_rep, class_size, cprod, induce, irr_chars,
perm_char, and restrict. In particular, the value at the identity element
(the degree, in the case of characters) is always listed first.
If f and g are two such class functions, cprod(f,g,R) computes the
standard (real) inner product of f and g; namely, the sum over i of
(1/m)*f[i]*g[i]*N_i, where N_i is the size of the i-th conjugacy class
and m=size(R). Note that this is not a complex Hermitian inner product.
The irreducible characters of W(R) are orthonormal with respect to cprod.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
chi:=perm_char([2,3],B3);
# compute the number of (A2,A2)-double cosets in B3:
cprod(chi,chi,B3); yields 4
# compute the multiplicities of irreducible characters in chi:
map(cprod,irr_chars(B3),chi,B3); yields [1,0,0,1,0,1,0,1,0,0]
SEE ALSO: class_rep, class_size, perm_char, induce, irr_chars, restrict,
size, structure
FUNCTION: diagram - Dynkin diagram of a root system
CALLING SEQUENCE: diagram(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
diagram(R) displays the Dynkin diagram of the root system R, with the
nodes numbered according to the ordering of simple roots used by base(R).
The displays for G2, H3, H4 and I2[m] are ugly.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
diagram(E8); yields
2
|
1---3---4---5---6---7---8
diagram(B3*D4); yields
1=<=2---3
5
|
4---6---7
SEE ALSO: base, name_of, structure
FUNCTION: degrees - degrees of the basic polynomial invariants
exponents - exponents of a root system
CALLING SEQUENCE: degrees(R);
exponents(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
degrees(R) returns a sorted list of the degrees of the basic polynomial
invariants of the Coxeter group W(R).
exponents(R) returns a sorted list of the exponents of R. The exponents
[e_1,...,e_n] have several equivalent definitions, one being that if m
is the Coxeter number of R and z is a primitive m-th root of unity, then
they are the unique positive integers < m such that z^(e_1),...,z^(e_n)
are the eigenvalues of a Coxeter element.
The exponents e_i and degrees d_i are related: d_i = e_i + 1.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
degrees(D6); yields [2,4,6,6,8,10]
exponents(H4); yields [1,11,19,29]
SEE ALSO: cox_number, length_gf, structure
FUNCTION: highest_root - highest root in an irreducible root system
CALLING SEQUENCE: highest_root(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
A vector v is dominant if it belongs to the closure of the fundamental
chamber; i.e., iprod(r,v) >= 0 for all simple roots r.
highest_root(R) returns a dominant root of R of maximum length. If R
is crystallographic and irreducible, there is a unique such root, the
so-called "highest root".
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
highest_root(C4); yields 2*e4
r:=highest_root(I2[5]);
evalf(r,3); yields .309*e1 + .951*e2
SEE ALSO: base, pos_roots, vec2fc, structure
FUNCTION: index - index of connection for a crystallographic root system
CALLING SEQUENCE: index(R);
PARAMETERS: R = a crystallographic root system data structure
SYNOPSIS:
The index of connection of a crystallographic root system R is the
index of the root lattice in the weight lattice. Equivalently, it is
the determinant of the Cartan matrix. It is also expressible as
char_poly(w,R,1), where w is a Coxeter element, or 1 + the number of
dominant minuscule weights, or (if R is irreducible) 1 + the number of
1's in the root coordinates of highest_root(R).
If the given root system is not crystallographic, an error is generated.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
index(D4); yields 4
index([e1-e2,2*e2]); yields 2
SEE ALSO: cartan_matrix, char_poly, highest_root, root_coords, structure,
weyl[minuscule]
FUNCTION: induce - induce characters from reflection subgroups
perm_char - permutation characters induced by reflection subgroups
CALLING SEQUENCE: induce(f,J,R); perm_char(J,R);
induce(f,S0,R); perm_char(S0,R);
PARAMETERS: R = a root system data structure
J = a list of integers in the range 1..n, where n=rank(R)
S0 = a list of simple roots for a root subsystem R' of R
f = a list representing a class function on W(R')
SYNOPSIS:
A character or class function on W(R) is represented as a list of values
[a_1,...,a_l], where a_i is the function value on an element in the i-th
conjugacy class. A consistent ordering of the conjugacy classes is used
by each of the functions class_rep, class_size, cprod, induce, irr_chars,
perm_char, and restrict. In particular, the value at the identity element
(the degree, in the case of characters) is always listed first.
If S0 is a list of simple roots for some (not necessarily parabolic)
root subsystem R' of R, and f is a list of values for some class function
on W(R'), then induce(f,S0,R) returns the class function on W(R) induced
by f, and perm_char(S0,R) returns the class function on W(R) induced by
the trivial character of W(R'); i.e., the character of the permutation
representation of W(R) on W(R)/W(R').
Similarly, if J is a sublist of [1,...,n] (where n = rank(R)), then
induce(f,J,R) and perm_char(J,R) perform the same calculations relative
to the parabolic subsystem of R whose base is obtained by selecting the
members of base(R) in positions indexed by J.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
perm_char([1,2],C3); yields [6,2,0,4,0,2,2,0,0,0]
S:=base(C3); r:=highest_root(C3);
perm_char([S[1],S[2],-r],C3); yields [3,1,0,3,1,3,1,3,1,0]
S:=base(H3); J:=[S[2],S[3]];
f:=[seq((-1)^nops(w),w=class_rep(J))]; # the sign character
induce(f,J,H3); yields [20,0,-4,0,2,0,0,0,0,0]
S:=base(A4); J:=[S[1],S[2],S[4]];
# the character of the reflection representation
f:=[seq(coeff(char_poly(w,J,-q),q),w=class_rep(J))];
induce(f,J,A4); yields [30,4,-2,0,-2,0,0]
SEE ALSO: base, class_rep, class_size, cprod, irr_chars, rank, restrict,
perm_rep, structure
FUNCTION: interior_pt - find an interior point of the fundamental chamber
CALLING SEQUENCE: interior_pt(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
interior_pt(R) returns a point in the interior of the fundamental chamber
defined by R; i.e., a vector v in the span of base(R) with the property
that iprod(r,v)>0 for all positive roots r. The vector v is chosen so
that iprod(r,v)=1 for each simple root r. For crystallographic R, this
is the same as weyl[co_rho](R).
More generally, if S is any list of independent vectors expressed as
linear combinations of the standard orthonormal basis e1,e2,...,
interior_pt(S) returns the vector v in the linear span of S such that
iprod(r,v)=1 for all members r of S.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
interior_pt(F4); yields e1+2*e2+3*e3+8*e4
interior_pt([e1,e2,e1-e3]); yields e1+e2
SEE ALSO: base, iprod, structure, vec2fc, weyl[co_rho]
FUNCTION: iprod - inner product of vectors
CALLING SEQUENCE: iprod(u,v);
PARAMETERS: u,v = linear combinations of e1,e2,...
SYNOPSIS:
A "vector" (distinct from the vector data structure used by Maple) is a
linear combination of the standard orthonormal basis e1,e2,e3,..., with
coefficients that are rational or floating-point.
If u and v are vectors, iprod(u,v) returns the inner product of u and v.
While u must have coefficients that are rational or floating-point, this
requirement is not necessary for v. All that is required for v is that
the function calls coeff(v,e1), coeff(v,e2),... return valid answers.
EXAMPLES:
iprod(e1+e2,e1-2*e2+e3); yields -1
iprod(e1+e2,a*e1+b*e2+c*e3); yields a+b
r:=highest_root(D4);
map(iprod,base(D4),r); yields [0,0,1,0]
SEE ALSO: reflect, root_coords, weyl[weight_coords]
FUNCTION: irr_chars - irreducible characters of a Coxeter group
CALLING SEQUENCE: irr_chars(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
A character of W(R) is represented as a list of values [a_1,...,a_l],
where a_i is the value of the character on an element in the i-th
conjugacy class. A consistent ordering of the conjugacy classes is used
by each of the functions class_rep, class_size, cprod, induce, irr_chars,
perm_char, and restrict. In particular, the degree of the character is
always the first value listed.
irr_chars(R) returns the list of irreducible characters of W(R).
The characters of the exceptional groups E-F-H are read from prestored
tables in the coxeter/lib directory. The characters for the remaining
irreducible groups are generated "on demand".
The characters of the group W(A.(n-1)) are listed in the same order as in
combinat[character](n). In particular, the ordering of the corresponding
Young diagrams is the reverse of combinat[partition](n).
The character values of the non-crystallographic groups H3 and H4 are
stored as expressions of the form a + b * sqrt(5), where a and b are
rational. Arithmetic operations involving these expressions are not
automatically simplified by Maple, but can be simplified through the use
of the expand and rationalize functions. The non-integer character values
of the groups I2[m] are generated as expressions of the form 2*cos(b*Pi)
with b rational. For certain values of b these expressions are subject
to automatic simplification by Maple as radical expressions.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
irr_chars(A2); yields [[1,1,1], [2,0,-1], [1,-1,1]]
map(x->op(1,x),irr_chars(H3)); yields [1,1,3,3,3,3,4,4,5,5]
SEE ALSO: class_rep, class_size, combinat[character], combinat[partition],
cprod, perm_char, induce, restrict, structure
FUNCTION: length_gf - length generating function for a Coxeter group
CALLING SEQUENCE: length_gf(R);
length_gf(R,z);
PARAMETERS: R = a root system data structure
z = a variable or expression (optional)
SYNOPSIS:
The length of an element w in W(R) is the minimum length of an expression
for w as a product of simple reflections. The length generating function
(or Poincare polynomial) P(q) for W(R) is the sum of q^length(w) for all
w in W(R).
length_gf(R,z) returns the length generating function for W(R) using the
formula P(z) = product((1-z^d[i])/(1-z),i=1..rank(R)), where d[1],d[2],...
are the degrees of the basic polynomial invariants for W(R). If the second
argument is omitted, q is used by default.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
length_gf(A2,z); yields z^3+2*z^2+2*z+1
f:=length_gf(B3)/length_gf(A2);
normal(f); yields q^6+q^5+q^4+2*q^3+q^2+q+1
SEE ALSO: degrees, rank, structure
FUNCTION: longest_elt - longest element of a Coxeter group
CALLING SEQUENCE: longest_elt(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
If R is a root system of rank n, members of the Coxeter group W(R) are
represented as lists of integers in the range 1..n. The group element
corresponding to w = [i_1,...,i_l] is the product of the generators
indexed by i_1,...,i_l. The indexing follows base(R).
longest_elt(R) returns a reduced expression for the longest element w0
of W(R); i.e., a minimum-length representation of w0. Among all reduced
expressions for w0, the one returned is the first in lexicographic order.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
longest_elt(H3); yields [1,2,1,2,1,3,2,1,2,1,3,2,1,2,3]
S:=base(A3);
longest_elt([S[1],S[3],S[2]]); yields [1,2,3,1,2,3]
SEE ALSO: base, length_gf, num_refl, reduce, structure
FUNCTION: multperm - multiply permutations
CALLING SEQUENCE: multperm(w,P);
multperm(w,P,m);
multperm(w,pg);
PARAMETERS: w = a list of integers representing a group element
P = a set (or list) of equations {s1=<perm1>,s2=<perm2>,...}
m = (optional) the common degree of the permutations in P
pg = a permutation group with generators s1,s2,...
SYNOPSIS:
Let w be a list [i_1,i_2,...,i_l] of positive integers. Normally w will
represent a product of generators in some Coxeter group.
Let P be a set (or list) of equations {s1=<perm1>,s2=<perm2>,...}, where
each expression <perm_i> is a permutation of 1,2,...,m in disjoint cycle
format. For a description of this format, see group[permgroup]. Normally
P will describe the action of the simple reflections in some permutation
representation of a Coxeter group.
multperm(w,P) returns the product of the permutations s.i_1 ,..., s.i_l,
using the convention that permutations act on the right. The result is
expressed in disjoint cycle format, canonically arranged so that (1) the
first listed element of each cycle is smallest, and (2) the cycles are
sorted by increasing first elements. Fixed points are omitted. A third
argument m indicates that each generator is a permutation of 1,...,m.
If pg is an expression of the form permgroup(m,P) (see group[permgroup]),
where m and P are as above, then multperm(w,pg) produces the same result.
For any root system R, the operation perm_rep(R) produces a permutation
representation of W(R) in this format.
To convert from permutations to reduced words in W(R) (i.e., the inverse
of multperm), use the function perm2word.
EXAMPLES:
P:={s1=[[6,7]],s2=[[7,8]]};
multperm([1,2],P); yields [[6,8,7]]
multperm([2,1],P,8); yields [[6,7,8]]
pg:=perm_rep(D4); w0:=longest_elt(D4);
multperm(w0,pg); yields [[1,8],[2,7],[3,6],[4,5]]
SEE ALSO: perm2word, perm_rep, group[permgroup]
FUNCTION: name_of - name of a root system or Coxeter group
CALLING SEQUENCE: name_of(R);
name_of(R,'pi');
PARAMETERS: R = a root system data structure
pi = (optional) a name
SYNOPSIS:
name_of(R) returns the name of the isomorphism type of the root system
or Coxeter group specified by R; i.e., a monomial in the names of the
irreducible root systems. If a second argument is specified, it will be
assigned a permutation [p_1,...,p_n] of [1,2,..,n] (n=rank(R)). This
permutation indicates an ordering of base(R) that is isomorphic to the
ordering used by base(N) and diagram(N), where N = name_of(R). Thus if
the permutation is [2,3,1] and S=base(R), then [S[2],S[3],S[1]] will be
an ordered base isomorphic to base(name_of(R)).
If R is a Coxeter matrix, then the assigned permutation (if requested)
indicates a re-ordering of the rows and columns of R that agrees with
cox_matrix(N), where N = name_of(R). Note also that in this case, the
name_of function cannot distinguish between B.n and C.n, or G2 and I2[6],
or B2 and I2[4]. In these cases, the name returned will be the first
member of each of these pairs.
If R is a list of simple roots, the name_of function will confirm that
R is a base for some root system, but in most cases does not attempt to
distinguish between crystallographic and non-crystallographic bases that
generate the same reflection group. Exceptions occur in rank two: if the
list uses floating-point coordinates and generates a reflection group of
order 8 or 12, then the name returned is I2[4] or I2[6], respectively.
If R is not a matrix or list, it is assumed that R itself is a root
system name and name_of(R) simply returns R. The assigned permutation
(if requested) is [1,2,...,n], where n=rank(R).
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
name_of([e1+e2,e1-e2]); yields A1^2
S:=base(F4); r:=highest_root(F4);
name_of([-r,S[2],S[3],S[4]],'pi'), pi; yields B4, [2,3,4,1]
m:=array([[1,5],[5,1]]);
name_of(m); yields I2[5]
name_of(E5); yields E5
m:=cartan_matrix(E5); name_of(m); yields D5
SEE ALSO: base, cartan_matrix, cox_matrix, diagram, rank, structure
FUNCTION: num_refl - number of reflections in a Coxeter group
CALLING SEQUENCE: num_refl(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
num_refl(R) returns the number of reflections in the Coxeter group W(R),
or equivalently the number of positive roots. The result is obtained by
evaluating the sum of the exponents of R.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
num_refl(B3*A3); yields 15
SEE ALSO: exponents, pos_roots, structure
FUNCTION: orbit - orbit of a vector under the action of a reflection group
CALLING SEQUENCE: orbit(v,R);
PARAMETERS: R = a root system data structure
v = a linear combination of e1,e2,...
SYNOPSIS:
A "vector" (distinct from the vector data structure used by Maple) is a
linear combination of the standard orthonormal basis e1,e2,e3,..., with
coefficients that are rational or floating-point.
If v is a vector, orbit(v,R) returns a list consisting of all vectors u
that can be obtained from W(R) acting on v by reflections. If any
floating-point coordinates occur in v or base(R), then the result is only
approximate in the sense that vectors u1 and u2 whose L^1 distance is
at most epsilon ( = 0.001, by default) are considered to be equal. Also,
vectors u such that iprod(r,u) <= epsilon are considered to not be on
the positive side of the hyperplane orthogonal to r.
To adjust epsilon, assign a new value to `coxeter/default`[epsilon].
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
orbit(e1+e2+e3,D3); yields [e1+e2+e3, e3-e1-e2, e2-e1-e3, e1-e2-e3]
with(weyl,weights); w:=weights(C4);
orbit(w[4],C4); yields [e4,e3,e2,e1,-e1,-e2,-e3,-e4]
SEE ALSO: base, iprod, orbit_size, structure, vec2fc
FUNCTION: orbit_size - size of a reflection group orbit
CALLING SEQUENCE: orbit_size(v,R);
orbit_size(v,R,-1);
PARAMETERS: R = a root system data structure
v = a linear combination of e1,e2,...
SYNOPSIS:
A "vector" (distinct from the vector data structure used by Maple) is a
linear combination of the standard orthonormal basis e1,e2,e3,..., with
coefficients that are rational or floating-point.
If v is a vector, orbit_size(v,S) returns the size of the orbit of W(R)
acting on v by reflections. This number is determined by finding a set
of reflections that generate the stabilizer of v. If any floating-point
coordinates occur in v or base(R), then there is a (small) potential for
error, in that the reflection corresponding to a root r is considered to
fix v if abs(iprod(r,v)) is at most epsilon ( = 0.001, by default).
If a third argument is present, the number returned is the size of the
union of the orbits of v and -v, or equivalently the size of the orbit
of v under the action of the group generated by -1 and W(R).
To adjust epsilon, assign a new value to `coxeter/default`[epsilon].
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
with(weyl,weights); w:=weights(D5);
orbit_size(w[1],D5); yields 16
orbit_size(w[1],D5,-1); yields 32
v:=base(H4)[2];
orbit_size(v,H4); yields 120
SEE ALSO: base, iprod, orbit, size, structure, vec2fc
FUNCTION: perm2word - convert a permutation to a reduced word
CALLING SEQUENCE: perm2word(pi,pg);
perm2word(pi,pg,sc);
PARAMETERS: pi = a permutation in disjoint cycle notation
pg = a permutation representation of a reflection group
sc = a stabilizer chain for pg (optional)
SYNOPSIS:
Let pi be a permutation of the integers 1,...,n for some n, in disjoint
cycle format. For a description of this format, see group[permgroup].
Let pg be a permutation representation of a reflection group in the
format produced by the function perm_rep. That is, pg should be an
unevaluated procedure call of the form
permgroup(n, {s1=<perm1>, s2=<perm2>,...}),
where each expression <perm_i> is a permutation of the integers 1,...,n
in disjoint cycle format.
perm2word(pi,pg) computes a reduced expression for the permutation pi
in terms of the generators of pg. More precisely, the result is a list
[i_1,...,i_l] of minimum length with the property that pi is the product
of the permutations s.i_1 ,..., s.i_l. If pi does not belong to the
permutation group specified by pg, FAIL is returned.
The first step of the algorithm is to use the stab_chain function to
determine a stabilizer chain for pg. To avoid repeating this step for
function calls involving the same permgroup, a precomputed stabilizer
chain can be supplied as a third argument. For a description of the
stabilizer chain format, see coxeter[stab_chain].
EXAMPLES:
pg:=permgroup(8, {s1=[[6,7]], s2=[[7,8]]});
sc:=stab_chain(pg);
perm2word([[6,8,7]],pg,sc); yields [1,2]
perm2word([[6,7,8]],pg,sc); yields [2,1]
pg:=perm_rep(H3); pi:=multperm([3,2,1,2,3],pg);
perm2word(pi,pg); yields [3,2,1,2,3]
SEE ALSO: multperm, perm_rep, stab_chain, group[permgroup]
FUNCTION: perm_rep - permutation representation of a Coxeter group
CALLING SEQUENCE: perm_rep(R); perm_rep(R,'gap');
perm_rep(J,R); perm_rep(J,R,'gap');
PARAMETERS: R = a root system data structure
J = a list or set of integers in the range 1..n (n = rank(R))
SYNOPSIS:
perm_rep(R) returns the permutation representation of W(R) on cosets
of the parabolic subgroup generated by all but the last of the simple
reflections, where "last" is determined by the ordering of base(R).
This representation is faithful if and only if R is irreducible.
More generally, if J is any list or set of distinct integers in the range
from 1 to n (where n = rank(R)), then perm_rep(J,R) returns the
permutation representation of W(R) on cosets of the parabolic subgroup
generated by the simple reflections indexed by J.
The output is expressed as a "permgroup" (see group[permgroup]). More
specifically, the result returned is an unevaluated procedure call
permgroup(m, {s1=<perm1>, s2=<perm2>,...})
where m is the degree of the permutation representation, and the
expression <perm_i> is a permutation of the integers 1,...,m in disjoint
cycle format that describes the action of the i-th simple reflection.
For a description of disjoint cycle format, see group[permgroup].
If the last argument is the name 'gap', then the output is a sequence of
commands that define the permutation group in the GAP language. For more
information about GAP, see <http://www.ccs.neu.edu/mirrors/GAP/NEU/>.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
perm_rep(B3); yields
permgroup(6,{s1=[[3,4]],s2=[[2,3],[4,5]],s3=[[1,2],[5,6]]})
perm_rep({1,3},A3); yields
permgroup(6,{s1=[[2,3],[4,5]],s2=[[1,2],[5,6]],s3=[[2,4],[3,5]]})
# a non-faithful permrep
perm_rep(A3*G2); yields permgroup(6,{s1=[],s2=[],s3=[],
s4=[[2,3],[4,5]],s5=[[1,2],[3,4],[5,6]]})
# a faithful permrep
pg:=perm_rep({1,2,4},A3*G2); with(group,grouporder);
grouporder(pg); yields 288
SEE ALSO: base, multperm, perm2word, perm_char, presentation, stab_chain,
structure, group[permgroup], group[permrep]
FUNCTION: pos_roots - positive roots of a root system
CALLING SEQUENCE: pos_roots(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
pos_roots(R) returns the list of all positive roots in the root system
specified by R. A root is positive if it is in the nonnegative linear
span of the simple roots.
If any floating-point coordinates occur in base(R), then the result is
only approximate in the sense that roots r1 and r2 whose L^1 distance
is at most epsilon ( = 0.001, by default) are considered to be equal.
To adjust epsilon, assign a new value to `coxeter/default`[epsilon].
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
pos_roots(B2); yields [e1, e2-e1, e2, e2+e1]
r:=highest_root(B2); S:=base(B2);
S:=[S[1],-r]; pos_roots(S); yields [e1, -e2-e1, -e2, e1-e2]
SEE ALSO: base, highest_root, num_refl, orbit, structure, weyl[rho]
FUNCTION: presentation - generators and relations for a Coxeter group
CALLING SEQUENCE: presentation(R);
presentation(R,'gap');
PARAMETERS: R = a root system data structure
SYNOPSIS:
presentation(R) returns the Coxeter presentation of W(R). The output is
a "grelgroup" (see group[grelgroup]). More specifically, the result
returned is an unevaluated procedure call
grelgroup({s1,s2,...}, {<rel1>, <rel2>,...})
where s1,s2,... are names for the simple reflections, and each expression
<rel_i> is a relation (i.e., a sequence of generators and inverses of
generators whose product in W(R) is the identity element).
If 'gap' is specified as a second argument, then a sequence of commands
that specify the Coxeter presentation of W(R) in the GAP language is
output via lprint(). These commands may be pasted into a GAP session.
For more on GAP, see <http://www.ccs.neu.edu/mirrors/GAP/NEU/>.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
presentation(A2); yields
grelgroup({s1,s2},{[s1,s1],[s2,s2],[s1,s2,s1,s2,s1,s2]})
#Is W(H3) generated by s1 and s2*s3 ?
g:=presentation(H3); with(group,cosets);
sg:=subgrel({t1=[s1],t2=[s2,s3]},g);
cosets(sg); yields {[]}
SEE ALSO: base, cox_matrix, perm_rep, structure, group[grelgroup]
FUNCTION: rank - rank of a root system or Coxeter group
CALLING SEQUENCE: rank(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
rank(R) returns the rank of the root system R; i.e., the dimension of the
vector space spanned by the roots of R, or equivalently, the number of
simple reflections in W(R).
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
rank(I2[7]); yields 2
rank(A3^2*B3*D10); yields 19
m:=cartan_matrix(C4); rank(m); yields 4
SEE ALSO: base, diagram, structure
FUNCTION: reduce - find a reduced expression for a group element
CALLING SEQUENCE: reduce(w,R);
reduce(w,R,'subword');
PARAMETERS: R = a root system data structure
w = a list of integers representing a member of W(R)
SYNOPSIS:
If R is a root system of rank n, members of the Coxeter group W(R) are
represented as lists of integers in the range 1..n. The group element
corresponding to w = [i_1,...,i_l] is the product of the generators
indexed by i_1,...,i_l. The indexing follows base(R).
reduce(w,R) returns a reduced expression for w; i.e., a minimum-length
representation of w. Among all reduced expressions for w, the one
returned is the first in lexicographic order. In particular, two
sequences w1 and w2 represent the same element of W(R) if and only if
reduce(w1,R) = reduce(w2,R).
If a third argument is present, the result returned is a reduced subword;
i.e., a reduced expression that can be obtained as a SUBSEQUENCE of w.
The algorithm for finding reduced subwords is based on the exchange
property, and has a running time that is quadratic in the length of w.
The default algorithm is linear with respect to length.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
reduce([1,2,3,1,2,3],A3); yields [2,1,3,2]
reduce([1,2,3,1,2,3],A3,'subword'); yields [2,3,1,2]
SEE ALSO: base, structure, vec2fc
FUNCTION: reflect - apply reflections to a vector
CALLING SEQUENCE: reflect(r,v);
reflect(r1,r2,...,v);
PARAMETERS: r,r1,r2,...,v = linear combinations of e1,e2,...
SYNOPSIS:
A "vector" (distinct from the vector data structure used by Maple) is a
linear combination of the standard orthonormal basis e1,e2,e3,..., with
coefficients that are rational or floating-point.
If r and v are vectors then reflect(r,v) will return the vector obtained
by reflecting v across the hyperplane orthogonal to r.
Although r is required to have coefficients that are rational or
floating-point, this requirement is not necessary for v. All that is
required for v is that the function calls coeff(v,e1), coeff(v,e2),...
return valid answers.
In the second form, if r1,r2,... is a sequence of zero or more vectors,
then reflect(r1,r2,...,v) returns the result of successively reflecting
v across the hyperplanes ...,r2,r1, in that order. In particular,
reflect(r1,r2,v) is equivalent to reflect(r1,reflect(r2,v)).
EXAMPLES:
reflect(e1+e2, e1+2*e2); yields -2*e1-e2
v:=reflect(e1+e2, a*e1+b*e2);
collect(v,{e1,e2}); yields -b*e1-a*e2
w0:=longest_elt(B4); S:=base(B4); v:=interior_pt(B4);
reflect(seq(S[i],i=w0),v); yields -e1-2*e2-3*e3-4*e4
SEE ALSO: interior_pt, iprod, orbit, vec2fc
FUNCTION: restrict - restrict characters to reflection subgroups
CALLING SEQUENCE: restrict(f,J,R);
restrict(f,S0,R);
PARAMETERS: R = a root system data structure
f = a list representing a class function on W(R)
J = a list of integers in the range 1..n, where n=rank(R)
S0 = a list of simple roots for a root subsystem of R
SYNOPSIS:
A character or class function on W(R) is represented as a list of values
[a_1,...,a_l], where a_i is the function value on an element in the i-th
conjugacy class. A consistent ordering of the conjugacy classes is used
by each of the functions class_rep, class_size, cprod, induce, irr_chars,
perm_char, and restrict. In particular, the value at the identity element
(the degree, in the case of characters) is always listed first.
If S0 is a list of simple roots for some (not necessarily parabolic)
root subsystem R' of R, and f is a list of values for some class function
on W(R), then restrict(f,SO,R) returns the class function obtained by
restricting f to W(R').
Similarly, if J is a sublist of [1,...,n] (where n = rank(R)), then
restrict(f,J,R) returns the restriction of f to W(R'), where R' denotes
the parabolic subsystem of R whose base is obtained by selecting the
members of base(R) in positions indexed by J.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
f:=[$1..nops(class_rep(C3))];
restrict(f,[1,2],C3); yields [1,4,2,6,7]
S:=base(C3); r:=highest_root(C3);
restrict(f,[S[1],S[2],-r],C3); yields [1,4,4,6,2,5,6,8,7,9]
SEE ALSO: base, class_rep, class_size, cprod, induce, irr_chars, rank,
perm_char, perm_rep, structure
FUNCTION: root_coords - coordinates of a vector w.r.t. simple roots
CALLING SEQUENCE: root_coords(v,R);
PARAMETERS: R = a root system data structure
v = a linear combination of e1,e2,...
SYNOPSIS:
A "vector" (distinct from the vector data structure used by Maple) is a
linear combination of the standard orthonormal basis e1,e2,e3,..., with
coefficients that are rational or floating-point.
If v is a vector in the span of base(R), root_coords(v,R) returns
the list of coordinates of v relative to the simple roots in base(R).
More generally, the second argument can be any list of independent vectors
and v can be any linear combination of e1,e2,... in their span, provided
that the function calls coeff(v,e1),coeff(v,e2),... return valid answers.
That is, the coefficients of v need not be rational or floating-point.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
root_coords(highest_root(G2),G2); yields [3,2]
root_coords(a*e1+b*e2+c*e3,B3); yields [a+b+c, b+c, c]
rc:=root_coords(2*e2,H3);
evalf(rc,3); yields [2.62, 3.24, 1.62]
SEE ALSO: base, structure, weyl[weight_coords]
FUNCTION: size - size of a Coxeter group
CALLING SEQUENCE: size(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
size(R) computes the size of the Coxeter group W(R) by evaluating the
product of the degrees of the basic polynomial invariants of W(R).
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
size(E8); yields 696729600
SEE ALSO: degrees, length_gf, orbit_size, structure
FUNCTION: stab_chain - stabilizer chain for a Coxeter group
CALLING SEQUENCE: stab_chain(pg);
PARAMETERS: pg = a permutation representation of a Coxeter group
SYNOPSIS:
For a finite permutation group W, a stabilizer chain is a sequence of
subgroups W = W_0 > W_1 > W_2 > ... > W_m = {1} with the property that
W_i is the subgroup of W_(i-1) that stabilizes some point b_i. Given a
set of (right) coset representatives X_i for W_i\W_{i-1}, each element
of W can be factored uniquely in the form w_m * ... * w_2 * w_1 with
w_i in X_i. (By convention, permutations act on the right.)
Let pg be a permutation representation of a Coxeter group W acting on
cosets of a (proper) parabolic subgroup, in the format produced by the
function perm_rep. That is, pg should be an unevaluated procedure call
of the form
permgroup(n, {s1=<perm1>, s2=<perm2>,...}),
where each expression <perm_i> is a permutation of 1,...,n in disjoint
cycle format. For a description of this format, see group[permgroup].
stab_chain(pg) computes a stabilizer chain for pg with the property that
each point-stabilizer in the chain is a parabolic subgroup. The output
format is a list [[b_1,O_1,X_1],[b_2,O_2,X_2],...], where b_1,b_2,... are
base points as above, O_1 is the list of points in the W-orbit of b_1,
and X_1 is the corresponding list of minimum-length coset representatives
for W modulo the stabilizer W_1 of b_1. More precisely, the j-th member
of X_1 is a word of minimum length such that the corresponding product
in W is a permutation sending b_1 to the j-th member of O_1. Similarly,
O_2 is the list of points in the W_1-orbit of b_2, and X_2 is the list
of minimum-length coset representatives for W_1 modulo the stabilizer W_2
of b_2 in W_1, and so on.
EXAMPLES:
pg:=perm_rep(B3); sc:=stab_chain(pg);
sc[1]; yields [1, [1,2,3,4,5,6],
[[],[3],[3,2],[3,2,1],[3,2,1,2],[3,2,1,2,3]]]
sc[2]; yields [2, [2,3,4,5], [[],[2],[2,1],[2,1,2]]]
sc[3]; yields [3, [3,4], [[],[1]]]
SEE ALSO: multperm, perm2word, perm_rep, group[permgroup]
HELP FOR: root system data structures
SYNOPSIS:
A root system data structure is any one of the following: a name, a list
of simple roots (i.e., a base), a Cartan matrix, or a Coxeter matrix.
Names:
The irreducible crystallographic root systems are named A1,A2,...,
B2,B3,..., C3,C4,..., D4,D5,..., E6,E7,E8,F4,G2. The irreducible
non-crystallographic root systems are named I2[4],I2[5],...., H3,H4.
A reducible root system name is obtained by forming a monomial out of
the names of the irreducible root systems. For example, a root system
consisting of the orthogonal direct sum of two copies of A2 and one
copy of D4 would be named A2^2*D4.
For convenience, B1,C1,C2,D2,D3,E3,E4,E5,I2[2],I2[3] are also allowed
as names of root systems, even though they are isomorphic to others
previously named. Also, the integer 1 is allowed as the name of the
empty root system.
Bases:
A root system can also be specified by a list of simple roots; i.e.,
a base. The names e1,e2,e3,... are reserved as an orthonormal basis for
the space containing the root system, and a root is a linear combination
of these basis vectors. For example, the list [e2-e1,e3-e2] is a base
for the root system A2. In a crystallographic root system, the
coefficients must be rational, but in a non-crystallographic root system,
the coefficients can be rational or floating-point (or a mix of the two).
Cartan matrices:
A crystallographic root system can also be specified by a Cartan matrix.
If [r_1,....,r_n] is a list of simple roots, then the corresponding
Cartan matrix is the n x n integer matrix whose (i,j)-entry is
2*iprod(r_i,r_j)/iprod(r_j,r_j). Since Maple does not support 0 x 0
matrices, the empty list [] is used as the Cartan matrix of the empty
root system.
Coxeter matrices:
A root system can also be (imperfectly) specified by a Coxeter matrix.
If s_1,...,s_n are the reflections corresponding to the simple roots of
a root system, then the associated Coxeter matrix is the n x n matrix
whose (i,j) entry is the order of s_i * s_j. (The Coxeter "matrix" of
the empty root system is the empty list [].) This matrix completely
specifies the Coxeter group generated by s_1,...,s_n, but non-isomorphic
root systems can have the same Coxeter matrix. In circumstances where
this distinction matters, a root system (crystallographic, if possible)
with this Coxeter matrix will be chosen by the function called.
EXAMPLE:
The root system A3 can be specified in any of the following four ways:
A3 # by name
[e2-e1,e3-e2,e1+e2] # a list of simple roots
array([[2,-1,0],[-1,2,-1],[0,-1,2]]) # a Cartan matrix
array([[1,3,2],[3,1,3],[2,3,1]]) # a Coxeter matrix
SEE ALSO: base, cartan_matrix, cox_matrix, name_of
FUNCTION: vec2fc - map a vector to the fundamental chamber by reflections
CALLING SEQUENCE: vec2fc(v,R);
vec2fc(v,R,'w');
PARAMETERS: R = a root system data structure
v = a linear combination of e1,e2,...
w = (optional) a name
SYNOPSIS:
A "vector" (distinct from the vector data structure used by Maple) is a
linear combination of the standard orthonormal basis e1,e2,e3,..., with
coefficients that are rational or floating-point. A vector v is dominant
relative to a set of simple roots S if it belongs to the closure of the
fundamental chamber defined by S; i.e., iprod(r,v) >= 0 for all r in S.
If v is a vector, vec2fc(v,R) returns the unique dominant vector (relative
to base(R)) that can be reached from v by a series of reflections.
If there is a third argument, it will be assigned the list of indices of
the simple reflections that were used to bring v into the fundamental
chamber. The list is ordered so that the first item in the list indexes
the first reflection applied to v. Therefore if S = base(R) and u is
the result returned by the function call vec2fc(v,R,'w'), then
v = reflect(seq(S[i],i=w),u).
Among all the possible sequences of simple reflections that send v to u,
the one assigned to the third argument has minimum length, and is first
in lexicographic order among all such minimum-length expressions.
WARNING: If any floating-point coordinates occur in v or base(R), then
the result is only approximate in the sense that a vector u is considered
to be on the negative side of the hyperplane orthogonal to r if and only
if iprod(r,u) < -epsilon ( = -0.001, by default).
To adjust epsilon, assign a new value to `coxeter/default`[epsilon].
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
vec2fc(-e1+2*e2,D4); yields 2*e4+e3
S:=base(F4);
vec2fc(-S[2],S,'w'),w; yields e4, [2,1,3,2,4,3,2,1]
SEE ALSO: base, interior_pt, iprod, orbit, rank, reflect, structure
FUNCTION: branch - restrict representations to reductive subalgebras
CALLING SEQUENCE: branch(v,J,R);
branch(v,J,R,<option>);
PARAMETERS: R = a crystallographic root system data structure
v = a dominant integral weight (linear combin. of e1,e2,...)
J = a list or set of integers in the range 1..n (n = rank(R))
<option> = one of the names 'klimyk' or 'mchain'
SYNOPSIS:
In a crystallographic root system R, weights are represented as rational
linear combinations of the standard orthonormal basis e1,e2,... A weight
v is integral if it is in the integer span of the fundamental weights
(i.e., weight_coords(v,R) is integral), and it is dominant if it is in
the nonnegative span of the fundamental weights. The irreducible finite-
dimensional representations ("irreps") of LieAlg(R) are indexed by
dominant integral weights.
If v is a dominant integral weight and J is a list or set of distinct
integers in the range 1..n (where n = rank(R)), branch(v,J,R) computes
the irreducible multiplicities that occur when the irrep indexed by v is
restricted to the (reductive) subalgebra of LieAlg(R) generated by a
Cartan subalgebra of LieAlg(R) and the root subspaces corresponding to
the simple roots indexed by J. The output is expressed as a linear
combination of the form m1*X[w1] + m2*X[w2] + ... , where w1,w2,... are
the weight coordinates of the highest weights of the irreducible summands
that occur, and m1,m2,... are their multiplicities.
Note that the highest weights of the irreducible summands that occur will
be dominant relative to the parabolic subsystem indexed by J, but not
necessarily dominant relative to J, so the terms X[..] that appear may
have negative coordinates in the positions not indexed by J.
In the extreme case J={}, computing branch(v,J,R) amounts to restricting
the irrep indexed by v to a Cartan subalgebra, and the coefficients in
the expansion are weight multiplicities. This is similar to computing
weight_mults(v,R), except that the latter uses a faster algorithm and
expresses the result in a compact form involving only dominant weights.
An optional fourth argument may be used to specify one of two available
algorithms for computing branching multiplicities:
'klimyk' (the default)
This algorithm is based on the Brauer-Klimyk Rule, and entails an
efficient search through the set of distinct weights that occur in the
irrep indexed by v. It has negligible space requirements, and is most
effective in the classical cases (types A-B-C-D) and in low rank.
The running time is nearly independent of J, and is largely a function
of the size of the search space; i.e., the sum of the terms in
map(orbit_size,weight_sys(v,R),R).
'mchain'
The Minuscule Chain algorithm entails an efficient search through the
crystal graph for the irrep indexed by v. The graph is embedded in a
product of minuscule or quasi-minuscule graphs (a "minuscule chain").
The algorithm has minimal space requirements, and the running time is
bounded by a factor proportional to the sum of the multiplicities in
the output. However, the proportion can vary drastically according to
how well the algorithm prunes the search tree.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
w:=weights(F4);
branch(w[1],{1,2,3},F4); yields
X[1,0,0,0] + X[0,1,0,-1] + X[1,0,0,-1]
w:=weights(A3); v:=2*w[1]+w[3];
branch(v,[2,3],A3,'mchain'); yields
X[2,0,1] + X[-2,2,1] + X[-1,1,0] + X[-3,2,0] + X[0,1,1] + X[1,0,0]
SEE ALSO: tensor, weight_mults, weights, coxeter[structure]
FUNCTION: minuscule - list minuscule and quasi-minuscule weights
CALLING SEQUENCE: minuscule(R);
minuscule(R,'quasi');
PARAMETERS: R = a crystallographic root system data structure
SYNOPSIS:
In a crystallographic root system R, weights are represented as rational
linear combinations of the standard orthonormal basis e1,e2,... A weight
v is integral if it is in the integer span of the fundamental weights
(i.e., weight_coords(v,R) is integral), and it is dominant if it is in
the nonnegative span of the fundamental weights.
A nonzero integral weight v is minuscule if and only if iprod(cr,v) <= 1
for all roots r, where cr = 2*r/iprod(r,r) denotes the co-root
corresponding to r. If R is irreducible, then v is quasi-minuscule if and
only if v satisfies iprod(cr,v) <= 2 for all co-roots cr and equality
occurs for some (unique) co-root cr. Alternatively, the short dominant
root is the unique dominant quasi-minuscule weight.
minuscule(R) returns the list of minuscule fundamental weights for R.
Note that if R is reducible, then there may be additional dominant
minuscule weights that are not fundamental weights.
minuscule(R,'quasi') returns the list of fundamental minuscule weights
for R, followed by the dominant quasi-minuscule weights for each
irreducible component of R.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
minuscule(C4); yields [e4]
minuscule(C4,'quasi'); yields [e4, e3+e4]
minuscule(F4*G2); yields []
minuscule(F4*G2,'quasi'); yields [e4, e7-e5]
SEE ALSO: weights, weight_coords, coxeter[pos_roots], coxeter[structure]
FUNCTION: rho - half the sum of the positive roots
co_rho - half the sum of the positive co-roots
CALLING SEQUENCE: rho(R);
co_rho(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
rho(R) returns half the sum of the positive roots of the root system R,
or equivalently, the sum of the fundamental weights of R.
co_rho(R) returns half the sum of the positive co-roots, or equivalently,
the unique vector v in the span of base(R) such that iprod(r,v)=1 for
each simple root r.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
rho(C3); yields e1+2*e2+3*e3
2*co_rho(C3); yields e1+3*e2+5*e3
SEE ALSO: weights, coxeter[base], coxeter[pos_roots], coxeter[structure]
FUNCTION: tensor - decompose tensor products of representations
CALLING SEQUENCE: tensor(u,v,R);
tensor(u,v,R,<option>);
PARAMETERS: R = a crystallographic root system data structure
u,v = dominant integral weights (linear combins. of e1,e2,...)
<option> = one of the names 'klimyk', 'mchain', or 'qtensor'
SYNOPSIS:
In a crystallographic root system R, weights are represented as rational
linear combinations of the standard orthonormal basis e1,e2,... A weight
v is integral if it is in the integer span of the fundamental weights
(i.e., weight_coords(v,R) is integral), and it is dominant if it is in
the nonnegative span of the fundamental weights. The irreducible finite-
dimensional representations ("irreps") of LieAlg(R) are indexed by
dominant integral weights.
If u and v are dominant integral weights, tensor(u,v,R) computes the
multiplicities in the irreducible decomposition of the tensor product of
the irreps indexed by u and v. The output is expressed as a linear
combination of the form m1*X[w1] + m2*X[w2] + ... , where w1,w2,... are
the weight coordinates of the dominant weights indexing the irreps that
occur in the tensor product, and m1,m2,... are their multiplicities.
An optional fourth argument may be used to specify one of three available
algorithms for computing tensor product multiplicities:
'klimyk' (the default)
This algorithm is based on the Brauer-Klimyk Rule, and entails an
efficient search through the set of distinct weights that occur in the
irrep indexed by u. It has negligible space requirements, and is most
effective in the classical cases (types A-B-C-D) and in low rank.
The running time is nearly independent of v, and is largely a function
of the size of the search space; i.e., the sum of the terms in
map(orbit_size,weight_sys(u,R),R).
'mchain'
The Minuscule Chain algorithm entails an efficient search through the
crystal graph for the irrep indexed by u. The graph is embedded in a
product of minuscule or quasi-minuscule graphs (a "minuscule chain").
The algorithm has minimal space requirements, and the running time is
bounded by a factor proportional to the sum of the multiplicities in
the output. However, the proportion can vary drastically according to
how well the algorithm prunes the search tree. If the irrep indexed
by v is significantly smaller than that of u, faster results will be
obtained by interchanging u and v.
'qtensor'
This algorithm uses q-specializations and interpolation methods to
compute tensor product multiplicities. It is most effective in the
exceptional cases, especially E6, E7, and E8, and least effective
in the type A cases. The main computational bottleneck amounts to
generating and solving a linear system whose dimension is roughly the
number of distinct irreducible constituents in the tensor product.
In particular, the space requirements will grow with both u and v,
and interchanging u and v will not affect the performance.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
w:=weights(G2);
tensor(w[2],w[2],G2); yields
X[0,2] + X[3,0] + X[0,1] + X[2,0] + X[0,0]
w:=weights(A3); u:=2*w[1]; v:=w[1]+w[3];
tensor(u,v,A3,'mchain'); yields
X[3,0,1] + X[1,1,1] + X[2,0,0] + X[0,1,0]
w:=weights(F4);
tensor(w[1],w[4],F4,'qtensor'); yields
X[1,0,0,1] + X[0,1,0,0] + X[1,0,0,0]
SEE ALSO: branch, toM, toX, weight_mults, weights, coxeter[structure]
FUNCTION: toM - convert polynomial expressions into orbit sums
toX - convert polynomial expressions into Weyl character sums
CALLING SEQUENCE: toM(f,R);
toX(f,R);
PARAMETERS: R = a crystallographic root system data structure
f = a polynomial expression in the character ring
SYNOPSIS:
If R is a crystallographic root system, the ring of characters for the
finite-dimensional representations of LieAlg(R) may be identified with
the W(R)-invariant part of the group ring of the weight lattice.
If v is a dominant integral weight whose fundamental weight coordinates
are [a_1,...,a_n] (n = rank(R)), then the expression X[a_1,...,a_n]
represents a Weyl character -- the element of the character ring
corresponding to the irreducible representation indexed by v.
Similarly, the expression M[a_1,...,a_n] represents an orbit sum -- the
element of the character ring obtained by adding the distinct members
of the W(R)-orbit of v.
If f is any polynomial expression in the Weyl characters X[..] and orbit
sums M[..], the function toX(f,R) converts f into a linear combination of
Weyl characters X[..]. Similarly, the function toM(f,R) converts f into a
linear combination of orbit sums M[..]. The underlying algorithms involve
the Brauer-Klimyk Rule (see weyl[tensor]), and a similar rule for
multiplying orbit sums.
Every variable that is not an indexed name of the form M[..] or X[..] is
regarded as part of the ground field, and the output is 'collect'ed with
respect to the variables X[..] (for 'toX') or M[..] (for 'toM').
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
f:=X[2,0,0]*(a*X[0,1,0]+b*X[0,0,2]);
toX(f,A3); yields
a*X[2,1,0] + b*X[2,0,2] + (a+b)*X[1,0,1] + b*X[0,0,0]
toX(M[0,1,0,0],F4); yields
X[0,1,0,0] - 2*X[0,0,0,1] - 3*X[1,0,0,0] + 5*X[0,0,0,0]
toM(M[0,1,0]*X[1,0,0],C3); yields
M[1,1,0] + 3*M[0,1,1] + 3*M[1,0,0] + 8*M[0,0,1]
toM(M[1,0]*M[0,1],G2); yields M[1,1] + 2*M[2,0] + 2*M[1,0]
SEE ALSO: tensor, weight_coords, weight_mults, coxeter[structure]
FUNCTION: weight_coords - coords of a vector w.r.t. fundamental weights
CALLING SEQUENCE: weight_coords(v,R);
PARAMETERS: R = a root system data structure
v = a linear combination of e1,e2,...
SYNOPSIS:
A "vector" (distinct from the vector data structure used by Maple) is a
linear combination of the standard orthonormal basis e1,e2,e3,..., with
coefficients that are rational or floating-point.
If v is a vector in the span of base(R), weight_coords(v,R) returns the
list of coordinates of v relative to the fundamental weights (weights(R)).
More generally, v can be any linear combination of e1,e2,..., provided
that the function calls coeff(v,e1),coeff(v,e2),... return valid answers.
That is, the coefficients of v need not be rational or floating-point.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
weight_coords(rho(F4),F4); yields [1,1,1,1]
weight_coords(a*e1+b*e2+c*e3,B3); yields [2*a, -a+b, -b+c]
SEE ALSO: weights, coxeter[root_coords], coxeter[structure]
FUNCTION: weight_sys - dominant weights below a given dominant weight
CALLING SEQUENCE: weight_sys(v,R);
weight_sys(v,R,'wc');
PARAMETERS: R = a crystallographic root system data structure
v = a dominant integral weight (linear combin. of e1,e2,...)
wc = (optional) a name
SYNOPSIS:
In a crystallographic root system R, weights are represented as rational
linear combinations of the standard orthonormal basis e1,e2,... A weight
v is integral if it is in the integer span of the fundamental weights
(i.e., weight_coords(v,R) is integral), and it is dominant if it is in
the nonnegative span of the fundamental weights. The irreducible finite-
dimensional representations ("irreps") of LieAlg(R) are indexed by
dominant integral weights.
If v is a dominant integral weight, weight_sys(v,R) returns the list of
all dominant integral weights that are less than or equal to v in the
partial ordering for which v1 < v2 whenever v2-v1 is an integral sum of
positive roots. These are the dominant weights that occur with nonzero
multiplicity in the irrep of LieAlg(R) indexed by v.
The output is sorted in order of decreasing height (the height of u is
defined to be iprod(u,co_rho(R)). In particular, the first listed weight
will be v, and the last weight will be minuscule or 0.
If a third argument is present, it is assigned a list consisting of
weight_coords(u,R) for each weight u appearing in weight_sys(v,R).
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
w:=weights(C3); v:=w[1]+w[3];
weight_sys(v,C3); yields [e1+e2+2*e3, 2*e3, e2+e3, 0]
w:=weights(G2); v:=3*w[1];
weight_sys(v,G2,'wc'): wc; yields
[[3,0],[1,1],[2,0],[0,1],[1,0],[0,0]]
SEE ALSO: minuscule, weight_coords, weight_mults, weights, weyl_dim,
coxeter[pos_roots], coxeter[structure]
FUNCTION: weight_mults - weight multiplicities in representations
CALLING SEQUENCE: weight_mults(v,R);
weight_mults(v,u,R);
PARAMETERS: R = a crystallographic root system data structure
u,v = dominant integral weights (linear combins. of e1,e2,...)
SYNOPSIS:
In a crystallographic root system R, weights are represented as rational
linear combinations of the standard orthonormal basis e1,e2,... A weight
v is integral if it is in the integer span of the fundamental weights
(i.e., weight_coords(v,R) is integral), and it is dominant if it is in
the nonnegative span of the fundamental weights. The irreducible finite-
dimensional representations ("irreps") of LieAlg(R) are indexed by
dominant integral weights.
If v is a dominant integral weight, weight_mults(v,R) computes the
dimensions of the weight spaces in the irrep indexed by v. The output is
expressed as a linear combination of the form c1*M[w1] + c2*M[w2] + ...,
where w1,w2,... are the weight coordinates of the dominant weights that
occur in the representation (see weyl[weight_sys]), and c1,c2,... are
their multiplicities. This may also be viewed as a formal expansion in
the character ring for LieAlg(R) in which each term M[..] represents an
orbit sum (see weyl[toM]).
In the second form, if u is an integral weight (possibly not dominant),
weight_mults(v,u,R) computes the multiplicity of the weight u in the
irrep indexed by v.
The algorithm used is essentially the same as the one given by Moody and
Patera (Bull. Amer. Math. Soc. 7 (1982), 237--242), which in turn is
based on Freudenthal's algorithm.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
w:=weights(C3); v:=w[1]+w[3];
weight_mults(v,C3); yields
M[1,0,1] + M[0,0,2] + 3*M[0,1,0] + 4*M[0,0,0]
u:=e1+e3;
weight_mults(v,u,C3); yields 3
weight_coords(u,C3); yields [1,-1,1]
SEE ALSO: tensor, toM, weight_sys, weights, weyl_dim, coxeter[structure]
FUNCTION: weights - fundamental weights for a root system
CALLING SEQUENCE: weights(R);
PARAMETERS: R = a root system data structure
SYNOPSIS:
weights(R) returns the list of fundamental weights for R.
If cr_1,...,cr_n are the simple co-roots for R, then the i-th fundamental
weight is the unique vector v_i in the span of base(R) such that
iprod(v_i,cr_j) = Kronecker_Delta(i,j).
If r is a root, then cr = 2*r/iprod(r,r) is the corresponding co-root.
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
weights([2*e1,2*(e2-e1)]); yields [e1+e2, 2*e2]
weights(G2); yields [-e1+e3,-e2-e1+2*e3]
SEE ALSO: rho, weight_coords, coxeter[co_base], coxeter[iprod],
coxeter[structure]
FUNCTION: weyl_dim - dimension of an irreducible representation
CALLING SEQUENCE: weyl_dim(v,R);
weyl_dim(v,R,q);
PARAMETERS: R = a crystallographic root system data structure
v = a dominant integral weight (linear combin. of e1,e2,...)
q = (optional) a variable or expression
SYNOPSIS:
In a crystallographic root system R, weights are represented as rational
linear combinations of the standard orthonormal basis e1,e2,... A weight
v is integral if it is in the integer span of the fundamental weights
(i.e., weight_coords(v,R) is integral), and it is dominant if it is in
the nonnegative span of the fundamental weights. The irreducible finite-
dimensional representations ("irreps") of LieAlg(R) are indexed by
dominant integral weights.
If v is a weight vector (not necessarily dominant or integral),
weyl_dim(v,R) returns the Weyl product
iprod(r,v+rho(R))
prod -----------------,
r iprod(r,rho(R))
where r ranges over pos_roots(R). If v is dominant integral, this is
the dimension of the irrep of LieAlg(R) indexed by v.
If a third argument q is present, then the result is a "q-analogue" of
the Weyl dimension formula; namely,
-iprod(co_rho(R),v) 1-q^iprod(cr,v+rho(R))
q * prod ----------------------,
r 1-q^iprod(cr,rho(R))
where cr = 2*r/iprod(r,r) denotes the co-root corresponding to r. This
may be viewed as a formal substitution of q^co_rho(R) into the character
of the representation indexed by v. As a formal series in q^(1/2), the
coefficients represent weight multiplicities for the principal embedding
of sl(2) in LieAlg(R).
For a description of root system data structures, see coxeter[structure].
EXAMPLES:
weyl_dim(weights(F4)[2],F4); yields 273
w:=weights(C2); v:=expand(a*w[1]+b*w[2]);
normal(weyl_dim(v,C2)); yields 1/6*(1+a)*(1+b)*(2+a+b)*(3+2*a+b)
weyl_dim(2*e2+e1,B2,q); yields q^(-5)*(1-q^7)*(1-q^5)/(1-q)^2
SEE ALSO: co_rho, rho, weight_coords, weights, coxeter[base],
coxeter[iprod], coxeter[pos_roots], coxeter[structure]