SchurRing -- The class of all Schur rings

Description

A Schur ring is the representation ring for the general linear group of n\times n matrices, and one can be constructed with schurRing.

i1 : S = schurRing(QQ,s,4)

o1 = S

o1 : SchurRing

Alternatively, its elements can be interpreted as virtual characters of symmetric groups, by setting the value of the option GroupActing to "Sn".

i2 : Q = schurRing(QQ,q,4,GroupActing => "Sn")

o2 = Q

o2 : SchurRing

The element corresponding to the Young diagram \{3,2,1\}, is obtained as follows.

i3 : s_{3,2,1}

o3 = s
      3,2,1

o3 : S

Alternatively, we can use a Sequence instead of a List as the index of a Schur function.

i4 : s_(3,2,1)

o4 = s
      3,2,1

o4 : S

For Young diagrams with only one row one can use positive integers as subscripts.

i5 : q_4

o5 = q
      4

o5 : Q

The name of the Schur ring can be used with a subscript to describe a symmetric function.

i6 : Q_{2,2}

o6 = q
      2,2

o6 : Q

i7 : S_5

o7 = s
      5

o7 : S

The dimension of the underlying virtual GL-representation can be obtained with dim.

i8 : dim s_{3,2,1}

o8 = 64

Multiplication in the ring comes from tensor product of representations.

i9 : s_{3,2,1} * s_{1,1}

o9 = s      + s      + s        + s      + s        + s
      4,3,1    4,2,2    4,2,1,1    3,3,2    3,3,1,1    3,2,2,1

o9 : S

i10 : q_{2,1} * q_{2,1}

o10 = q  + q    + q
       3    2,1    1,1,1

o10 : Q

To extract data in an element in a SchurRing, use listForm:

i11 : listForm (s_{3})^2

o11 = {({6}, 1), ({5, 1}, 1), ({4, 2}, 1), ({3, 3}, 1)}

o11 : List

i12 : q_{2,1} * q_{2,1}

o12 = q  + q    + q
       3    2,1    1,1,1

o12 : Q

i13 : listForm oo

o13 = {({3}, 1), ({2, 1}, 1), ({1, 1, 1}, 1)}

o13 : List

By varying the option GroupActing one obtains Schur rings for a wide range of classical groups. The "Sp" flavor is the representation ring of the symplectic group Sp(2n); multiplication in this ring is governed by the Newell–Littlewood rule rather than the Littlewood–Richardson rule.

i14 : Sp = schurRing(QQ,sp,4,GroupActing => "Sp");

i15 : sp_{2,1} * sp_{1,1}

o15 = sp    + sp      + sp  + sp      + sp        + 2sp    + sp      + sp
        3,2     3,1,1     3     2,2,1     2,1,1,1      2,1     1,1,1     1

o15 : Sp

i16 : dim sp_{2,1}

o16 = 160

i17 : exteriorPower(2,sp_{1})

o17 = sp    + sp
        1,1     ()

o17 : Sp

For the orthogonal flavor "O" one must further specify the parity of the ambient vector space via OddOrEven. For instance, O(5) (type B_2) is obtained as follows.

i18 : O5 = schurRing(QQ,oo5,5,GroupActing => "O",OddOrEven => "Odd");

i19 : dim oo5_{2,2,1}

o19 = 5005

The rational-GL flavor "RatGL" implements virtual GL-modules whose weights may be negative, using the (\alpha,\beta) pair convention.

i20 : Rg = schurRing(QQ,r,3,GroupActing => "RatGL");

i21 : r_({2,1},{1})

o21 = r
       {{2, 1}, {1}}

o21 : Rg

i22 : r_({1},{}) * r_({},{1})

o22 = r           + r
       {{1}, {1}}    {{}, {}}

o22 : Rg

One can also iterate the construction to form tensor products of Schur rings, which is useful for bivariate characters.

i23 : S = schurRing(QQ,s,4);

i24 : T = schurRing(S,t,3);

i25 : (s_{2,1} + t_{1,1})^2

o25 = t    + t      + 2s   t    + (s    + s      + s    + 2s      + s       
       2,2    2,1,1     2,1 1,1     4,2    4,1,1    3,3     3,2,1    3,1,1,1
      -----------------------------------------------------------------------
      + s      + s       )t
         2,2,2    2,2,1,1  ()

o25 : T

Functions and methods returning a Schur ring:

schurRing(Ring,Symbol,ZZ) -- see schurRing -- Make a SchurRing
schurRing(Ring,Thing) -- see schurRing -- Make a SchurRing
schurRing(Ring,Thing,ZZ) -- see schurRing -- Make a SchurRing

Methods that use a Schur ring:

branch(RingElement,SchurRing,SchurRing) -- see branch -- Restrict a Schur, Sp, or O character along a two-factor subgroup
coefficientRing(SchurRing) -- Coefficient ring of a Schur ring
numgens(SchurRing) -- Number of generators of Schur ring.
SchurRing _ List
SchurRing _ Sequence
SchurRing _ ZZ
specialize(RingElement,ZZ,SchurRing) (missing documentation)
toGL(RingElement,SchurRing) -- see toGL -- Express an element in the plain GL Schur basis
toM(RingElement,SchurRing) -- see toM -- Monomial (m-) basis representation
toO(RingElement,SchurRing) -- see toO -- Expansion in the basis of orthogonal characters
toRatGL(RingElement,SchurRing) -- see toRatGL -- Lift a Schur (GL, SL) character into a rational-GL Schur ring
toS(RingElement,SchurRing) -- see toS -- Schur (s-) basis representation
toSn(RingElement,SchurRing) -- see toSn -- Promote a Schur-basis element into an Sn character ring
toSp(RingElement,SchurRing) -- see toSp -- Expansion in the basis of symplectic characters

For the programmer

The object SchurRing is a type, with ancestor classes EngineRing < Ring < Type < MutableHashTable < HashTable < Thing.

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

SchurRing -- The class of all Schur rings

Description

See also

Functions and methods returning a Schur ring:

Methods that use a Schur ring:

For the programmer