|
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
In this section, we describe more complicated functions for dealing with representation decompositions.
Subsections
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.
RestrictionMatrix(R, S) : RootDtm, RootDtm -> AlgMatElt
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.
Constructing a restriction 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)
]
KLPolynomial(x, y) : GrpPermElt, GrpPermElt -> RngUPolElt
Ring: RngUPol Default: Z[X]
The Kazhdan-Lusztig polynomial Px, y.
We use the recursion given originally by Kazhdan and Lusztig [KL79].
RPolynomial(x, y) : GrpPermElt, GrpPermElt -> RngUPolElt
Ring: RngUPol Default: Z[X]
The R-polynomial Rx, y.
There is a relation between Kazhdan-Lusztig polynomials and R-polynomials. We should have, for any x, w ∈W:
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
> testKL(Random(W), Random(W));
LHS: X^3 - 1
RHS: X^3 - 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.
Exponents of A3:
> 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.
Conversion to and from 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).
PartitionToWeight(l) : ModTupFldElt -> ModTupFldElt
PartitionToWeight(l) : ModTupRngElt -> ModTupRngElt
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.
WeightToPartition(v) : ModTupFldElt -> ModTupFldElt
WeightToPartition(v) : ModTupRngElt -> ModTupRngElt
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.
TransposePartition(l) : ModTupFldElt -> ModTupFldElt
TransposePartition(l) : ModTupRngElt -> ModTupRngElt
The transpose partition of l.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
