Other Functions for Representation Decompositions

In this section, we describe more complicated functions for dealing with representation decompositions.

FundamentalClosure(R, S): RootDtm, SetEnum -> SetEnum

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.

Closure(R, S): RootDtm, SetEnum -> SetEnum

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, Q): RootDtm, SeqEnum -> AlgMatElt

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.

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.

Example: Constructing a Restriction Matrix (ex-017a6f)

Run in calculator (opens in a new tab)Copy input

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)
]

Run in calculator (opens in a new tab)Copy input

KLPolynomial(x, y): GrpPermElt, GrpPermElt -> RngUPolElt

Ring: RngUPol                    Default: PolynomialRing(Integers())

The Kazhdan-Lusztig polynomial \(P_{x,y}\). We use the recursion given originally by Kazhdan and Lusztig [KL79].

RPolynomial(x, y): GrpPermElt, GrpPermElt -> RngUPolElt

Ring: RngUPol                    Default: PolynomialRing(Integers())

The \(R\)-polynomial \(R_{x,y}\).

Example: Kazhdan-Lusztig and R-Polynomials (ex-3fc4eb)

Run in calculator (opens in a new tab)Copy input

There is a relation between Kazhdan-Lusztig polynomials and \(R\)-polynomials. We should have, for any \(x, w \in W\):

\[X^{l(w) - l(x)} \overline{P_{x,w}} - P_{x,w} = \sum_{x < y \leq w} R_{x,w} P_{y,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

Run in calculator (opens in a new tab)Copy input

Exponents(R): RootDtm -> SeqEnum

The exponents of a Root datum \(R\) form a sequence of numbers \(e_1, \ldots, e_r\), where \(r\) is the rank of \(R\), such that the polynomial \(\sum_{w \in W} X^{l(w)}\) decomposes as a product \(\prod_{i=1}^r \sum_{j=0}^{e_i} X^j\). They are given in weakly increasing order.

Example: Exponents of a Coxeter Group (ex-9b36b7)

Run in calculator (opens in a new tab)Copy input

Exponents of \(A_3\):

> 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

Run in calculator (opens in a new tab)Copy input

ToLiE(D): LieRepDec -> MonStgElt

The LiE equivalent of the decomposition \(D\).

FromLiE(R, p): RootDtm, MonStgElt -> LieRepDec

The decomposition of the representation over \(R\) that is equivalent to \(p\), where \(p\) is a polynomial in LiE-syntax.

Example: Conversion to and from LiE (ex-a9c639)

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 ]

Run in calculator (opens in a new tab)Copy input

Operations Related to the Symmetric Group

In this section, we describe some functions taken from LiE for dealing with the Symmetric group.

ConjugationClassLength(l): SeqEnum -> RngIntElt

The order of the conjugation class of \(S_n\) of permutations of cycle type \(l\) (for \(n\) the sum of the elements of \(l\)).

PartitionToWeight(l): SeqEnum -> SeqEnum

PartitionToWeight(l): ModTupRngElt -> ModTupRngElt

Let \(n\) be the number of parts of \(l\), then the function returns the weight for a group of type \(A_{n-1}\) corresponding to \(\lambda\), expressed on the basis of fundamental weights.

WeightToPartition(v): SeqEnum -> SeqEnum

WeightToPartition(v): ModTupRngElt -> ModTupRngElt

Let \(n\) be the length of \(v\), then \(v\) is interpreted as a weight for a group of type \(A_n\), 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): SeqEnum -> SeqEnum

TransposePartition(l): ModTupRngElt -> ModTupRngElt

The transpose partition of \(l\).

FusionRules

In this section, we describe a function for computing fusion rules using the Kac-Walton formular, as described in Section 16.2 of [FMS97].

WZWFusion(R, v, w, k): RootDtm, Any, Any, RngIntElt -> SetMulti

ReturnForm: MonStgElt                    Default: "Auto"

Compute the fusion rules for weights \(v \times 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.

WZWFusion(D, E, k): LieRepDec, LieRepDec, RngIntElt -> LieRepDec

Compute the fusion rules for representations \(D\) and \(E\) at level \(k\).

Example: WZW Fusion Rules (ex-fa246b)

Run in calculator (opens in a new tab)Copy input

Fusion rules at level \(3\) for B\(_3\) (using finite weights first, affine weights second)

> 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)
*}

Run in calculator (opens in a new tab)Copy input