In this section, basic access and arithmetic operations for weight multisets are described. Addition generally corresponds to direct sum of representations. The other arithmetic operations do not necessarily correspond to meaningful operations on the corresponding representation.
The Root datum over which the weight multiset D is defined.
The sequences of weights and multiplicities in the weight multiset D.
The weights and multiplicities of the weight multiset D as a normal multiset consisting of vectors.
The multiplicity of the weight v in the weight multiset D.
Returns true if, and only if, the weight multisets D and E are identical, i.e. they are defined over identical root data, with equal weights and multiplicities.
The sum (union) of weight multisets D and E, i.e. this corresponds to the direct sum of the two decomposition multisets. The underlying root data must be the same.Add Vv to D. The length of v must be equal to dim(RD).
Add the weight multiset E to D. RD must be equal to RE.
Add c times the weight multiset E to D. The integer c may be omitted, in which case it is assumed to be equal to 1. The root data of D and E must be identical.
Add the weight v to the multiset D. The weight v must be a sequence of length d or an element of Zd, where d is the dimension of the root datum R.
Add c times the weight v to the multiset D. The integer c may be omitted, in which case it is assumed to be equal to 1. The length of v must be equal to the dimension of the root datum of D.
Add the weight v to the multiset D. The length of v must be equal to the dimension of the root datum of D.
The multiset whose weights are equal to those of D, and whose multiplicities are c times the multiplicities of D.
The multiset whose weights are equal to those of D, and whose multiplicities are the multiplicities of D divided by c. An error is flagged if any of the multiplicities of D is not divisible by c.
Multiply all multiplicities of the weight multiset D by c.
Divide all multiplicities of the weight multiset D by c. An error is flagged if a multiplicity of D is not divisible by c.
The product of the two weight multisets D and E, viewed as polynomials as in the LiE package [vLCL92]. The root datum of the resulting decomposition is the direct sum of the root data of D and E. Note that this is does not correspond to the direct sum or tensor product of representations.
The product of the two weight multisets D and E, viewed as polynomials as in the LiE package [vLCL92]. The product is interpreted as a weight multiset over the root datum R. An error is flagged if the dimension of R is not the sum of the dimensions of the root data of D and E.
Let k be the length of the sequence Q. The resulting decomposition E has Root datum S, and to each highest weight of D corresponds a highest weight w' of E, with w'i = wQ[i], where i = 1, ..., k. The multiplicities of E are equal to the multiplicities of D, but one should note that E might in fact have fewer unique highest weights than D, especially if k < dim(RD). The dimension of the root datum S must be equal to k.
Permute the components of the weights in the multiset D by the permutation π and interpret the result as a weight multiset over the root datum S. If the underlying root datum of D has dimension d, then S must also have dimension d and π must be an element of Sym(d).
> R := RootDatum("A2" : Isogeny := "SC");
> D := LieRepresentationDecomposition(R, [[2,3],[4,3]], [1,3]);
> D:Maximal;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 2 of type A2
Dimension of weight space:2
Weights:
[
(2 3),
(4 3)
]
Multiplicities:
[ 1, 3 ]
> E := D + [5,2];
> E:Maximal;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 2 of type A2
Dimension of weight space:2
Weights:
[
(2 3),
(4 3),
(5 2)
]
Multiplicities:
[ 1, 3, 1 ]
> PermuteWeights(E, Sym(2)!(1,2), R):Maximal;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 2 of type A2
Dimension of weight space:2
Weights:
[
(3 2),
(3 4),
(2 5)
]
Multiplicities:
[ 1, 3, 1 ]
> S := RootDatum("A1" : Isogeny := "SC");
> SubWeights(E, [2], S):Maximal;
Highest weight decomposition of representation of:
S: Simply connected root datum of dimension 1 of type A1
Dimension of weight space:1
Weights:
[
(3),
(2)
]
Multiplicities:
[ 4, 1 ]
Functions for converting between different kinds of weight multiset (decomposition, character, and dominant character multisets). Note that it is the users responsibility to keep track of what kind of multiset they are using. If a function that expects one kind of set receives another, the output is likely to be meaningless.
The virtual decomposition multiset of the virtual module with dominant character multiset C. The second version is provided for convenience, and equivalent to VirtualDecomposition(LieRepresentationDecomposition(R,v)).
The decomposition multiset of the module with dominant character multiset C. An error is flagged if D is virtual, i.e. if dominant weights occur with negative multiplicities.
Returns the dominant character multiset with decomposition D.
As described earlier, many operations on representations carry over naturally to operations on their decompositions. This section describes the various functions for this purpose that were ported from LiE.
Note that many functions in this sections have two variants: one that takes decompositions as an argument and one that takes a root datum and a highest weight.
The dimension of the module with decomposition polynomial D. The algorithm used is described in [vLCL92].
The dimension of the module with highest weight v over the root datum R. The algorithm used is described in [vLCL92].
The value of the quadratic Casimir on representation with highest weight w, normalised to take the value 2 on the highest weight of the adjoint representation. This function is due to Dr. Bruce Westbury, University of Warwick.
Two Multisets of positive integers, Num and Den, which should be read as follows. Take the product of the integers in Num and divide by the product of the integers in Den to get the ordinary dimension. Replacing each integer by the quantum integer will give the quantum dimension. This function is due to Dr. Bruce Westbury, University of Warwick.
> R := RootDatum("D4" : Isogeny := "SC");
> D := AdjointRepresentationDecomposition(R);
> RepresentationDimension(D);
28
> wts, mps := WeightsAndMultiplicities(D); wts,mps;
[
(0 1 0 0)
]
[ 1 ]
> num,den := QuantumDimension(R, wts[1]); num,den;
{* 4^^2, 7 *}
{* 1, 2^^2 *}
> &*num/&*den;
28
Virtual: BoolElt Default: false
The decomposition polynomial of the restriction to ToGrp of the irreducible module Vv with respect to the restriction matrix M. The matrix M must have dim(FromGrp) rows and Dim(ToGrp) columns.The matrix M is used in such a way that any weight v' (expressed on the basis of fundamental weights for g), when restricted to a torus of ToGrp, becomes the weight v'M (expressed on the basis of fundamental weights for ToGrp). A suitable restriction matrix can often be obtained by use of RestrictionMatrix. The algorithm used is described in [vLCL92].
The optional argument Virtual may be set to true to allow occurrence of virtual weights.
Virtual: BoolElt Default: false
As Branch(FromGrp, ToGrp, v, M) but with the irreducible module v replaced by the module with decomposition D.
This function attempts to perform the inverse operation of Branch, namely to reconstruct an R-module from its restriction to RD.Please note that in LiE one must supply the inverse of the matrix used in Branch. Magma, however, is able to compute inverses itself, so one needs to provide the matrix used in Branch, and not its inverse.
M must be a square matrix whose dimension is equal to the dimension of RD. The dimension of R must be equal to the dimension of RD as well. The algorithm used is described in [vLCL92].
> R := RootDatum("D4" : Isogeny := "SC");
> S := RootDatum("A3T1" : Isogeny := "SC");
> M := RestrictionMatrix(R, S);
> br := Branch(R, S, [1,0,0,0], M);
> br;
Highest weight decomposition of representation of:
S: Simply connected root datum of dimension 4 of type A3
Number of terms: 2
> cl := Collect(R, br, M);
> cl:Maximal;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 4 of type D4
Dimension of weight space:4
Weights:
[
(1 0 0 0)
]
Multiplicities:
[ 1 ]
Goal: Any Default:
The decomposition multiset of the tensor product of the representations with highest weights v and w over the root datum R.If the optional parameter Goal is set, only the multiplicity of the irreducible module with highest weight Goal is returned. This does not greatly speed up the process, as the same computational steps need to be made, but it will significantly reduce memory consumption. The algorithm used is described in [vLCL92].
Goal: Any Default:
The decomposition multiset of the tensor product of the representations with decomposition multisets D and E.If the optional parameter Goal is set, only the multiplicity of the irreducible module with highest weight Goal is returned. This does not greatly speed up the process, as the same computational steps need to be made, but it will significantly reduce memory consumption. The algorithm used is described in [vLCL92].
Goal: Any Default:
The decomposition multiset of the tensor product of the representations with decomposition multisets in the sequence Q.If the optional parameter Goal is set, only the multiplicity of the irreducible module with highest weight Goal is returned. This does not greatly speed up the process, as the same computational steps need to be made, but it will significantly reduce memory consumption. The algorithm used is described in [vLCL92].
The decomposition of the n-th tensor power of VRv or D.
> R := RootDatum("D4" : Isogeny := "SC");
> DAd := AdjointRepresentationDecomposition(R);
> pwrs := function(D, n)
> Q := [D];
> for i in [2..n] do
> Q[i] := Tensor(Q[1], Q[i-1]);
> end for;
> return Q;
> end function;
> time Q := pwrs(DAd, 7);
Time: 4.900
> [ #q : q in Q ];
[ 1, 7, 15, 30, 54, 91, 143 ]
> DH := LieRepresentationDecomposition(R, [2,2,0,0]);
> time Q := pwrs(DH, 4); [ #q : q in Q ];
Time: 99.070
[ 1, 105, 390, 1017 ]
The decomposition polynomial of the virtual module obtained by applying the n-th Adams operator to VRv or D. The algorithm used is described in [vLCL92].
The decomposition polynomial of Sn(VRv), the n-th symmetric tensor power of VRv.In the second form the irreducible module VRv is replaced by the module with decomposition D. The algorithm used is described in [vLCL92].
The decomposition polynomial of (Alt)n(VRv), the n-th alternating tensor power of VRv.In the second form the irreducible module VRv is replaced by the module with decomposition D. The algorithm used is described in [vLCL92].
The decomposition multiset of the RD-module of the plethysm of VRv corresponding to the partition λ. Here λ should be a partition of d= dim VRv, i.e., a non-increasing sequence consisting of positive integers with sum d. The value returned is the decomposition multiset of the representation of RD that is obtained by composing the representation of RD afforded by VRv, with the representation of (GL)(VRv) corresponding to the partition λ. The classical Frobenius formula is used (see [And77] and [JK81]).In the second form the irreducible module VRv is replaced by the module with decomposition D.
Let n be the last entry of the sequence t; the toral element t ∈T will act in any representation of R as a diagonalisable transformation, all of whose eigenvalues are n-th roots of unity. This function returns a sequence in which the i-th entry is the multiplicity of the eigenvalue ζi in the action of the toral element t on the irreducible module VRv (or the module with decomposition D, in the second case). Here ζ is the complex number e2 π i /n.See Section Toral Elements for a description of the format of t.
Spectrum provides a means to recognise toral elements in a more natural form. [vLCL92, Section 5.7.3].
> R := RootDatum("A4" : Isogeny := "SC");
> stdrep := [1,0,0,0];
> t := [1,0,0,0,2];
> stdrep := [1,0,0,0];
> Spectrum(R, stdrep, t);
[ 3, 2 ]
/* Showing that t has 3 eigenvalues 1 (1st root of unity),
and 2 eigenvalues -1 (2nd root of unity) */
/* We may use the following function for constructing
toral elements of A_n in the LiE format: */
> mktoral := function(b, d)
> r := [ (i eq 1)
> select b[i]
> else b[i-1]+b[i] mod d
> : i in [1..(#b-1)]
> ];
> r[#b] := d;
> return r;
> end function;
> t2 := mktoral([0,0,0,1,1], 2); t2;
[ 0, 0, 0, 1, 2 ]
/* We restrict to a one parameter subgroup */
> RM := Transpose(Matrix([[0,0,0,1]]));
> T1 := RootDatum("T1" : Isogeny := "SC");
> Branch(R, T1, stdrep, RM):Maximal;
Highest weight decomposition of representation of:
T1: Toral root datum of dimension 1
Dimension of weight space:1
Weights:
[
(1),
(0),
(-1)
]
Multiplicities:
[ 1, 3, 1 ]
/* Indicating that the element of that one parameter
subgroup parametrised by some complex number z has
one eigenvalue z^-1, three eigenvalues 1, and one
eigenvalue z in the standard representation. */
Starting with the highest weight v of R, or the decomposition D, repeatedly apply the Demazure operator Mαi, taking for i the successive entries of the Weyl word w (viewed as product of simple reflections).
Equivalent to Demazure(R, v, w) or Demazure(D, w) where w is the longest word of the Coxeter group of R or RD.If D is a decomposition polynomial, then the result E is the character polynomial of this decomposition. This is not the most efficient way to compute characters, but it can be very useful in checking other algorithms, since only the most elementary manipulations are involved.
> R := RootDatum("D4" : Isogeny := "SC");
> DAd := AdjointRepresentationDecomposition(R);
> DAdCp := Demazure(DAd); DAdCp;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 4 of type D4
Number of terms: 25
> DAd2 := AlternatingDominant(DAdCp); DAd2;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 4 of type D4
Number of terms: 1
> DAd2 eq DAd;
true
In the first form, compute the tensor product of the irreducible An representations with highest weights v and w using the Littlewood-Richardson rule. In the second form, compute the tensor product of the representations with decompositions D and E.This procedure converts the weights to partitions, computes the tensor product using the Littlewood-Richardson rule (as described above, see LittlewoodRichardsonTensor), and converts the result back to a weight multiset.
> R := RootDatum("A2" : Isogeny := "SC");
> v := [1,2];
> w := [1,1];
> D1 := Tensor(R, v, w);
> D1;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 2 of type A2
Weights:
[
(0 1),
(2 0),
(0 4),
(3 1),
(2 3),
(1 2)
]
Multiplicities:
[ 1, 1, 1, 1, 1, 2 ]
> D2 := LittlewoodRichardsonTensor(R, v, w);
> D2;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 2 of type A2
Weights:
[
(1 2),
(2 3),
(2 0),
(0 4),
(0 1),
(3 1)
]
Multiplicities:
[ 2, 1, 1, 1, 1, 1 ]
> D1 eq D2;
true
So the results are identical, as they should be. We could also convert
the weights to partitions by hand, directly compute the Littlewood-
Richardson tensor, and compare that to the previous result:
> vp := WeightToPartition(v); wp := WeightToPartition(w);
> vp, wp;
[ 3, 2, 0 ]
[ 2, 1, 0 ]
> parts, mps := LittlewoodRichardsonTensor(vp, wp);
> parts, mps;
[
(4 4 0),
(4 3 1),
(3 3 2),
(5 3 0),
(5 2 1),
(4 2 2)
]
[ 1, 2, 1, 1, 1, 1 ]
> [ PartitionToWeight(p) : p in parts ];
[
(0 4),
(1 2),
(0 1),
(2 3),
(3 1),
(2 0)
]
So that again gives the same representation.
Finally, note that in some cases computing tensor products using the
Littlewood-Richardson rule may be faster than computing them in the
normal way:
> R := RootDatum("A8" : Isogeny := "SC");
> v := [0,0,2,0,1,0,1,2];
> w := [0,2,1,2,0,0,1,0];
> time _ := Tensor(R, v, w);
Time: 2.630
> time _ := LittlewoodRichardsonTensor(R, v, w);
Time: 0.210
Alternating Dominant of the representation with decomposition D or the irreducible representation Vwt, with respect to Weyl group element w. Starting with D, the following operation is repeatedly applied, taking for i the successive entries of w (viewed as reflection). For any (weight, multiplicity) pair (v, c) of D let vi = < v, αi > be its coefficient of wi; the term is
- --
- unaltered if vi ≥0,
- --
- removed if vi = - 1, and
- --
- replaced by ((v + wi)ri - wi, - c) if vi = - 2. As a result of the operation for i, the coefficient vi is made non-negative without affecting the image Mαi(D) under the Demazure operator, and hence also without changing the value of its alternating Weyl sum AlternatingWeylSum.
Equivalent to (but somewhat faster than) the previous AlternatingDominant(D, w) and AlternatingDominant(R, wt, w), with w the longest element of the corresponding Weyl group. If D is interpreted as dominant weights with multiplicities, then the result E contains highest weights and multiplicities.
> R := RootDatum("D4" : Isogeny := "SC");
> v := [1,5,2,1];
> Dec1 := LieRepresentationDecomposition(R, v);
> // First, we construct the character polynomial for the
> // module with highest weight lambda
> Dom := DominantCharacter(Dec1 : InBasis := "Weight"); Dom;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 4 of type D4
Number of terms: 176
> W := CoxeterGroup(R); #W; act := RootAction(W);
192
> domwts, dommps := WeightsAndMultiplicities(Dom);
> CP := LieRepresentationDecomposition(R);
> for i in [1..#domwts] do
> wt := domwts[i]; mp := dommps[i];
> wtor := WeightOrbit(W, wt : Basis := "Weight");
> for wti in wtor do
> AddRepresentation(~CP, wti, mp);
> end for;
> end for;
> CP;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 4 of type D4
Number of terms: 17712
> time ad := AlternatingDominant(CP); ad:Maximal;
Time: 54.200
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 4 of type D4
Dimension of weight space:4
Weights:
[
(1 5 2 1)
]
Multiplicities:
[ 1 ]
> time adalt := AlternatingDominant(CP, LongestElement(W));
Time: 8.330
> ad eq adalt;
true
The alternating Weyl sum of VRv or D. Useful for demonstration purposes, but the fact that the number of terms in the result is a multiple of the order of the CoxeterGroup of R makes it impractical for most groups.