In this section, we describe more complicated functions for dealing with representation decompositions.
A set of fundamental roots in the minimal subsystem (not necessarily closed!) of the root system R that contains all the roots in S. This function is equivalent to the fundam function in LiE.The set S should contain either roots or root indices; the returned set will then contain objects of the same type.
A set of fundamental roots in the minimal subsystem (not necessarily closed!) of the root system R that contains all the roots in S. This function is equivalent to the closure function in LiE.The set S should contain either roots or root indices; the returned set will then contain objects of the same type.
For a simply connected root datum R and a sequence of roots Q forming a fundamental basis for a closed subdatum S of R, this function computes a restriction matrix for the fundamental Lie subgroup of type S of the Lie group corresponding to R.The sequence Q may contain either integers (where i corresponds to the i-th root of R) or vectors (interpreted as root vectors written in the root basis of R).
Note that the result is not unique. Moreover, if the result is to be used by Branch or Collect the roots in Q must be positive roots, and their mutual inner products must be non-positive.
Let S be a sub root datum of R, constructed for example (but not necessarily) using a call to sub<...>. Then the matrix M returned by this function maps the fundamental weights of R to those of S. Note that, if the rank of S is smaller than the rank of R, there will be more than one such matrix.
> R := RootDatum("D4": Isogeny := "SC");
> sub<R | [1,3,4]>;
Root datum of dimension 4 of type A1 A1 A1
[ 1, 3, 4, 13, 15, 16 ]
> S := RootDatum("A1A1A1T1" : Isogeny := "SC");
> M := RestrictionMatrix(R, S); M;
[ 1 0 0 -1]
[ 0 1 0 -2]
[ 0 0 1 -1]
[ 0 0 0 4]
> imgR := FundamentalWeights(R)*M; imgR;
[ 1 0 0 -1]
[ 0 1 0 -2]
[ 0 0 1 -1]
[ 0 0 0 4]
> FundamentalWeights(S);
[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
/* M is of the required form, since: */
> [ BasisChange(S, BasisChange(S, imgR[i]
> : InBasis := "Standard", OutBasis := "Weight")
> : InBasis := "Weight", OutBasis := "Standard")
> : i in [1..4]
> ];
[
(1 0 0 0),
(0 1 0 0),
(0 0 1 0),
(0 0 0 0)
]
Ring: RngUPol Default: Z[X]
The Kazhdan-Lusztig polynomial Px, y. We use the recursion given originally by Kazhdan and Lusztig [KL79].
Ring: RngUPol Default: Z[X]
The R-polynomial Rx, y.
Xl(w) - l(x) /line(Px, w) - Px, w = ∑x < y ≤w Rx, w Py, w,
where the bar indicates a sign change of all the exponents. We need some fiddling around in order to implement this sign change, since Magma doesn't support negative exponents at the moment, but we can make it work:
> signchange := function(pol, pwr)
> //returns X^pwr * bar(pol)
> deg := Degree(pol);
> P := Parent(pol);
> if (deg gt pwr) then return "Failed: Can't do sign change"; end if;
> return (P.1)^(pwr-deg)*P!Reverse(Eltseq(pol));
> end function;
> testKL := function(x, w)
> W := Parent(x);
> rng<X> := PolynomialRing(Integers());
> lenw := CoxeterLength(W, w);
> lenx := CoxeterLength(W, x);
>
> if (lenx gt lenw) then
> return "Failed: l(x) > l(w) gives zero R and KL polynomials.";
> end if;
>
> /* Left hand side */
> Pxw := KLPolynomial(x, w : Ring := rng);
> lhs := signchange(Pxw, lenw - lenx);
> if (Type(lhs) eq MonStgElt) then return lhs; end if;
> lhs -:= Pxw;
>
> /* Right hand side */
> rhs := rng!0;
> lvl := {w};
> lvllen := lenw;
> while (lvllen gt lenx and #lvl gt 0) do
> for y in lvl do
> rhs +:= RPolynomial(x,y : Ring := rng)*
> KLPolynomial(y, w : Ring := rng);
> end for;
> lvl := BruhatDescendants(lvl : z := x);
> lvllen -:= 1;
> end while;
>
> /* Done */
> printf "LHS: %o\n", lhs;
> printf "RHS: %o\n", rhs;
> return lhs eq rhs;
> end function;
> W := CoxeterGroup("D4");
> x := W.1*W.2*W.1;
> w := W.1*W.2*W.3*W.4*W.1*W.2;
> testKL(x,w);
LHS: X^3 + X^2 - X - 1
RHS: X^3 + X^2 - X - 1
true
The exponents of a Root datum R form a sequence of numbers e1, ..., er, where r is the rank of R, such that the polynomial ∑w ∈W Xl(w) decomposes as a product ∏i=1r ∑j=0ei Xj. They are given in weakly increasing order.
> W := CoxeterGroup("A3"); #W;
24
> P<X> := PolynomialRing(Integers());
> f := &+[ X^(CoxeterLength(W, w)) : w in W ]; f;
X^6 + 3*X^5 + 5*X^4 + 6*X^3 + 5*X^2 + 3*X + 1
> R := RootDatum("A3" : Isogeny := "SC");
> exp := Exponents(R); exp;
[ 1, 2, 3 ]
> g := [ &+[ X^j : j in [0..e] ] : e in exp ]; g;
[
X + 1,
X^2 + X + 1,
X^3 + X^2 + X + 1
]
> f eq &*g;
true
The LiE equivalent of the decomposition D.
The decomposition of the representation over R that is equivalent to p, where p is a polynomial in LiE-syntax.
> R := RootDatum("B3" : Isogeny := "SC");
> D := LieRepresentationDecomposition(R, [1,2,3]);
> s := ToLiE(D); s;
1X[1,2,3]
> FromLiE(R, s):Maximal;
Highest weight decomposition of representation of:
R: Simply connected root datum of dimension 3 of type B3
Dimension of weight space:3
Weights:
[
(1 2 3)
]
Multiplicities:
[ 1 ]
In this section, we describe some functions taken from LiE for dealing with the Symmetric group.
The order of the conjugation class of Sn of permutations of cycle type l (for n the sum of the elements of l).
Let n be the number of parts of l, then the function returns the weight for a group of type An - 1 corresponding to λ, expressed on the basis of fundamental weights.
Let n be the length of v, then v is interpreted as a weight for a group of type An, and the expression of that weight in n + 1 partition coordinates is returned. When v is dominant, this is a partition with n + 1 parts.
The transpose partition of l.
In this section, we describe a function for computing fusion rules using the Kac-Walton formular, as described in Section 16.2 of [FMS97].
ReturnForm: MonStgElt Default: "Auto"
Compute the fusion rules for weights v x w of R at level k using the Kac-Walton formula. The weights v and w may be given either as finite weights (i.e. vectors or sequences with rank(R) entries) or as affine weights (i.e. vectors or sequences with rank(R)+1 entries).The optional argument ReturnForm should be "Auto" (in which case the weights returned will be finite weights or affine weights depending on what v and w are; the default), "Finite" (in which case the weights returned are finite weights), or "Affine" (in which case the weights returned are affine weights).
Note that R should be a weakly simply connected root datum.
Compute the fusion rules for representations D and E at level k.
> R := RootDatum("B3" : Isogeny := "SC");
> WZWFusion(R, [0,0,1],[1,0,1], 3);
{*
(2 0 0),
(1 1 0),
(0 0 2),
(1 0 2),
(1 0 0),
(0 1 0)
*}
> WZWFusion(R, [0,0,1],[1,0,1], 3 : ReturnForm := "Affine");
{*
(2 0 0 1),
(1 0 2 0),
(0 1 0 1),
(1 0 0 2),
(0 0 2 1),
(1 1 0 0)
*}