Macaulay2 » Documentation
Packages » SchurRings :: toRatGL
next | previous | forward | backward | up | index | toc

toRatGL -- Lift a Schur (GL, SL) character into a rational-GL Schur ring

Description

A GroupActing "RatGL" ring represents rational GL characters with bipartition weights $(\alpha, \beta)$, where $\alpha$ is the positive part and $\beta$ the negative part of the highest weight. See Koike, On the decomposition of tensor products of the representations of classical groups, Adv.\ Math.\ 74 (1989). Ordinary GL/SL Schur characters $s_\lambda$ embed as rational characters with trivial second weight, $s_{\lambda, ()}$; toRatGL performs this embedding coefficientwise.

The IndexedVariableTable for a RatGL ring accepts either a bipartition ($s_{\{\alpha,\beta\}}$) or a plain partition ($s_{2,1}$, which is implicitly $s_{\{2,1\},\{\}}$).

i1 : G = schurRing(QQ, getSymbol "g", infinity, GroupActing => "GL");
i2 : R = schurRing(QQ, getSymbol "sRat", infinity, GroupActing => "RatGL");
i3 : toRatGL(g_{2,1} + 3 * g_1, R)

o3 = sRat             + 3sRat
         {{2, 1}, {}}        {{1}, {}}

o3 : R

The simplest embedding sends the standard GL character $s_{1}$ to the rational character $s_{(1),()}$. A slightly richer input (here an LR product re-expressed by toRatGL) goes through coefficientwise, so the GL-basis expansion on the right matches the one on the left:

i4 : toRatGL(g_{2,1}, R)

o4 = sRat
         {{2, 1}, {}}

o4 : R
i5 : toRatGL(g_{1} * g_{1}, R)

o5 = sRat          + sRat
         {{2}, {}}       {{1, 1}, {}}

o5 : R

Rational GL characters admit negative powers of the determinant. The bipartition $s_{(), (1)}$ is the dual of the standard representation, and the tensor product of the standard with its dual decomposes as $s_{(1),(1)} \oplus s_{(),()}$ (the adjoint representation plus the trivial):

i6 : Rdual = schurRing(QQ, ratD, infinity, GroupActing => "RatGL");
i7 : ratD_{{1},{}} * ratD_{{},{1}}

o7 = ratD           + ratD
         {{1}, {1}}       {{}, {}}

o7 : Rdual

If f already lives in a RatGL ring, it is re-embedded into the target R. When R has finite rank $n$, a pair $(\alpha,\beta)$ with $\ell(\alpha)+\ell(\beta) \leq n$ is admissible and $s_{\alpha,\beta}$ is left unchanged; otherwise the Koike–Terada modification rule is applied. The rule iteratively removes a border strip of length $L = \ell(\alpha)+\ell(\beta)-n-1$ starting at the first box of the last row, from both $\alpha$ and $\beta$, contributing a sign $(-1)^{c(R_\alpha)+c(R_\beta)-1}$ per step (where $c(R)$ counts the columns the strip occupies), until the result is admissible. The character vanishes if at some step $L = 0$ or either partition admits no border strip of the required length.

The admissible boundary case $\ell(\alpha)+\ell(\beta) = n+1$ therefore always vanishes ($L = 0$):

i8 : S = schurRing(QQ, getSymbol "sStab", infinity, GroupActing => "RatGL");
i9 : T = schurRing(QQ, getSymbol "sFin",  3,        GroupActing => "RatGL");
i10 : toRatGL(sStab_{{1,1},{1,1}} + sStab_{{1},{1}}, T)

o10 = sFin
          {{1}, {1}}

o10 : T

Embedding the stable bipartitions $((2,1),(\,))$, $((1,1,1),(\,))$, and $((1),(1,1))$ into a finite-rank $GL(2)$ rational ring keeps the first and kills the last two. The first is admissible; the other two hit the boundary $\ell(\alpha)+\ell(\beta) = n+1 = 3$ so $L = 0$:

i11 : Tfin2 = schurRing(QQ, getSymbol "sFin2", 2, GroupActing => "RatGL");
i12 : toRatGL(sStab_{{2,1},{}}, Tfin2)

o12 = sFin2
           {{2, 1}, {}}

o12 : Tfin2
i13 : toRatGL(sStab_{{1,1,1},{}}, Tfin2)

o13 = 0

o13 : Tfin2
i14 : toRatGL(sStab_{{1},{1,1}}, Tfin2)

o14 = 0

o14 : Tfin2

When $\ell(\alpha)+\ell(\beta) > n+1$ the rule is genuinely non-trivial and can produce a non-zero modified bipartition with a sign. For instance, at $GL(3)$ with $\alpha = (4,3,2,2)$ and $\beta = (5,2,2,1,1)$ the rule removes a border strip of length $5$ from each partition, leaving $(4,1,1)$ and $(5,1)$; a further pass (now with $L=1$) strips one box from each, giving $(4,1)$ and $(5)$ with an overall sign of $-1$:

i15 : Tfin3 = schurRing(QQ, getSymbol "sFin3", 3, GroupActing => "RatGL");
i16 : toRatGL(sStab_{{4,3,2,2},{5,2,2,1,1}}, Tfin3)

o16 = -sFin3
            {{4, 1}, {5}}

o16 : Tfin3

Another non-trivial example at $GL(4)$: the columns $(1^3,1^3)$ satisfy $\ell(\alpha)+\ell(\beta) = 6 > n+1 = 5$, so one border strip of length $L = 1$ is removed from each, producing $(1^2,1^2)$ with an overall sign of $-1$:

i17 : Tfin4 = schurRing(QQ, getSymbol "sFin4", 4, GroupActing => "RatGL");
i18 : toRatGL(sStab_{{1,1,1},{1,1,1}}, Tfin4)

o18 = -sFin4
            {{1, 1}, {1, 1}}

o18 : Tfin4

See also

Ways to use toRatGL:

  • toRatGL(RingElement,SchurRing)
  • toRatGL(RingElement) (missing documentation)

For the programmer

The object toRatGL is a method function.


The source of this document is in /build/reproducible-path/macaulay2-1.26.05+ds/M2/Macaulay2/packages/SchurRings.m2:8667:0.