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

SchurRings -- Rings representing irreducible representations of general linear or symmetric groups

Description

This package makes computations in the representation rings of general linear groups and symmetric groups possible.

Given a positive integer n we may define a polynomial ring in n variables over an arbitrary base ring , whose monomials correspond to the irreducible representations of GL(n), and where multiplication is given by the decomposition of the tensor product of representations. We create such a ring in Macaulay2 using the schurRing function.

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

o1 = S

o1 : SchurRing
i2 : R = schurRing(r,infinity)

o2 = R

o2 : SchurRing

Note that in the above, n is allowed to be equal to \infty. However, in this version of the package, many of the features from the case n finite are missing from the infinite case, so the user is advised to use large values for n as a substitute, whenever necessary.

We determine the relative dimension of a SchurRing over its base using the numgens function:

i3 : numgens S

o3 = 4
i4 : numgens R

o4 = infinity

o4 : InfiniteNumber

For k\leq n, one may interpret the degree k homogeneous component of a SchurRing as the representation ring of the symmetric group S_k. In this ring, the multiplication is different than the one in the representation ring of GL(n). By default, the elements of a SchurRing are interpreted as (virtual) characters of a general linear group. This interpretation is controlled by the option GroupActing, whose default value is "GL". To indicate that the elements of a Schur ring should be interpreted as characters of the symmetric group, one has to set the option GroupActing to "Sn".

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

o5 = Q

o5 : SchurRing

A monomial in S represents the irreducible representation with a given highest weight. The standard GL(4)-representation is

i6 : V = s_1

o6 = s
      1

o6 : S

We may see the dimension of the corresponding irreducible representation using dim:

i7 : dim V

o7 = 4

Multiplication of elements corresponds to tensor product of representations. The value is computed using a variant of the Littlewood-Richardson rule.

i8 : V * V

o8 = s  + s
      2    1,1

o8 : S
i9 : V^3

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

o9 : S

The third symmetric power of V is obtained by

i10 : W = s_{3}

o10 = s
       3

o10 : S
i11 : dim W

o11 = 20

and the third exterior power of V can be obtained using

i12 : U = s_{1,1,1}

o12 = s
       1,1,1

o12 : S
i13 : dim U

o13 = 4

Alternatively, one can use the functions symmetricPower and exteriorPower:

i14 : W = symmetricPower(3,V)

o14 = s
       3

o14 : S
i15 : U = exteriorPower(3,V)

o15 = s
       1,1,1

o15 : S

We can in fact take symmetric powers and exterior powers of any representation:

i16 : exteriorPower(2,W)

o16 = s    + s
       5,1    3,3

o16 : S
i17 : symmetricPower(2,U)

o17 = s
       2,2,2

o17 : S

and compute even more general forms of plethysm:

i18 : plethysm(W+U,W+U)

o18 = s  + s    + 2s      + 2s    + s      + 2s        + 2s      + 2s      +
       9    7,2     7,1,1     6,3    6,2,1     6,1,1,1     5,3,1     5,2,2  
      -----------------------------------------------------------------------
      3s        + 2s      + 2s        + 2s        + 2s      + 2s
        5,2,1,1     4,4,1     4,3,1,1     4,2,2,1     3,3,3     3,2,2,2

o18 : S

Alternatively, we can use the binary operator @ to compute plethysm:

i19 : s_2 @ s_3

o19 = s  + s
       6    4,2

o19 : S
i20 : (W+U) @ (W+U)

o20 = s  + s    + 2s      + 2s    + s      + 2s        + 2s      + 2s      +
       9    7,2     7,1,1     6,3    6,2,1     6,1,1,1     5,3,1     5,2,2  
      -----------------------------------------------------------------------
      3s        + 2s      + 2s        + 2s        + 2s      + 2s
        5,2,1,1     4,4,1     4,3,1,1     4,2,2,1     3,3,3     3,2,2,2

o20 : S

All the above calculations assume that we're dealing with representations of GL(4). But as symmetric functions of degree three, W and U, can be thought of as characters of the symmetric group S_3. Let us first ``move'' these symmetric functions into a Schur ring designed to deal with characters of symmetric groups (like the ring Q defined above):

i21 : W' = toS(W,Q)

o21 = q
       3

o21 : Q
i22 : U' = toS(U,Q)

o22 = q
       1,1,1

o22 : Q

Now W' corresponds to the trivial representation of S_3, and U' to the sign representation. As such, we can tensor them together using the function internalProduct, or the binary operator *.

i23 : W' * U'

o23 = q
       1,1,1

o23 : Q

We can generate the class function corresponding to an S_n-representation, using the function classFunction:

i24 : cfW = classFunction(W')

o24 = ClassFunction{{1, 1, 1} => 1}
                    {2, 1} => 1
                    {3} => 1

o24 : ClassFunction
i25 : cfU = classFunction(U')

o25 = ClassFunction{{1, 1, 1} => 1}
                    {2, 1} => -1
                    {3} => 1

o25 : ClassFunction

We can multiply class functions together, and transform class functions into symmetric functions using the function symmetricFunction:

i26 : cfWU = cfW * cfU

o26 = ClassFunction{{1, 1, 1} => 1}
                    {2, 1} => -1
                    {3} => 1

o26 : ClassFunction
i27 : symmetricFunction(cfWU,Q)

o27 = q
       1,1,1

o27 : Q

The result of the previous computation is of course the same as that of taking the product of W' and U'.

We can take exterior and symmetric powers of S_n-representations, just as for GL-modules (compare to o16 and o17):

i28 : exteriorPower(2,W')

o28 = 0

o28 : Q
i29 : symmetricPower(2,U')

o29 = q
       3

o29 : Q

We can write any symmetric function in terms of the standard e- (elementary symmetric), h- (complete) and p- (power sum) bases, using the functions toE, toH, toP respectively:

i30 : toE U

o30 = e
       3

o30 : QQ[e ..e , p ..p , h ..h ]
          1   4   1   4   1   4
i31 : toH U

       3
o31 = h  - 2h h  + h
       1     1 2    3

o31 : QQ[e ..e , p ..p , h ..h ]
          1   4   1   4   1   4
i32 : toP W

      1 3   1       1
o32 = -p  + -p p  + -p
      6 1   2 1 2   3 3

o32 : QQ[e ..e , p ..p , h ..h ]
          1   4   1   4   1   4

These expressions live in the Symmetric ring associated to S, which can be obtained using the function symmetricRing:

i33 : A = symmetricRing S

o33 = A

o33 : PolynomialRing

Similarly, any Symmetric ring has a Schur ring attached to it, which can be obtained using the function schurRing:

i34 : schurRing A === S

o34 = true

We construct tensor products of Schur rings iteratively by allowing Schur rings over base rings that are also Schur rings:

i35 : T = schurRing(S,t,3)

o35 = T

o35 : SchurRing

The Schur ring T can thus be thought of as the representation ring of GL(V)\times GL(V'), where V is as before a vector space of dimension 4, and V' is a vector space of dimension 3. The representation corresponding to V' is

i36 : V' = t_1

o36 = t
       1

o36 : T

The function schurLevel indicates the number of Schur rings that have been tensored together to obtain any given ring:

i37 : schurLevel T

o37 = 2
i38 : schurLevel S

o38 = 1
i39 : schurLevel QQ

o39 = 0

We can now check Cauchy's formula for decomposing symmetric/exterior powers of a tensor product:

i40 : symmetricPower(3,V*V')

o40 = s t  + s   t    + s     t
       3 3    2,1 2,1    1,1,1 1,1,1

o40 : T
i41 : exteriorPower(3,V*V')

o41 = s     t  + s   t    + s t
       1,1,1 3    2,1 2,1    3 1,1,1

o41 : T

We end with the computation of the GL(n)- and S_n-equivariant resolutions of the residue field of a polynomial ring in n variables. The function that does this calculation, schurResolution, is based on an empirical method, which gives the correct answer in surprisingly many situations.

In the GL(n) situation, we are resolving the residue field which as a representation has character 1_S. The space of linear forms in the polynomial ring considered as a GL-representation has character V = s_1.

i42 : n = 4

o42 = 4
i43 : M = {1_S}

o43 = {s  }
        ()

o43 : List
i44 : schurResolution(V,M,DegreeLimit => n)

o44 = {{(0, s  )}, {(1, s )}, {(2, s   )}, {(3, s     )}, {(4, s       )}}
             ()          1          1,1          1,1,1          1,1,1,1

o44 : List

Not surprisingly, the syzygy modules are generated by the exterior powers of V.

The residue field as a representation of the symmetric group S_n has character s_n. The space of linear forms in the polynomial ring considered as an S_n-representation coincides with the permutation representation of S_n, thus has character s_n + s_{n-1,1}.

i45 : rep = q_n + q_(n-1,1)

o45 = q  + q
       4    3,1

o45 : Q
i46 : M = {q_n}

o46 = {q }
        4

o46 : List
i47 : sR = schurResolution(rep,M,DegreeLimit => n)

o47 = {{(0, q )}, {(1, q  + q   )}, {(2, q    + q     )}, {(3, q      +
             4          4    3,1          3,1    2,1,1          2,1,1  
      -----------------------------------------------------------------------
      q       )}, {(4, q       )}}
       1,1,1,1          1,1,1,1

o47 : List

We can check that the second syzygy module is generated by the second exterior power of the permutation representation.

i48 : eP2rep = exteriorPower(2,rep)

o48 = q    + q
  3,1    2,1,1

o48 : Q
i49 : eP2rep == last sR#2#0

o49 = true

Variant character rings. Beyond the general linear and symmetric groups, the package supports several other families of representation rings. All of them are realized as SchurRings, with behavior controlled by the option GroupActing (and, for basis conversions, Basis). The current values are:

$\bullet$ "GL" (default): polynomial representations of $GL_n$, with basis the Schur functions $s_\lambda$ and the Littlewood-Richardson product.

$\bullet$ "Sn": the representation ring of the symmetric group $S_n$, with basis indexed by partitions and product the internal product (Kronecker product of $S_n$-characters). See internalProduct.

$\bullet$ "Sp": the (universal or finite-rank) character ring of the symplectic groups, with basis $sp_\lambda$ and product the Newell-Littlewood product. See toSp.

$\bullet$ "O": the (universal or finite-rank) character ring of the orthogonal groups, with basis $o_\lambda$. The finite-rank ring distinguishes type $B$ and type $D$ via the option OddOrEven. See toO.

$\bullet$ "RatGL": the ring of rational (i.e. finite-dim'l) representations of $GL_n$, whose irreducibles are indexed by bipartitions $(\alpha,\beta)$. See toRatGL.

$\bullet$ "SL": the ring of polynomial representations of $SL_n$ (rows of length $n$ are killed).

Orthogonally, the option Basis $=>$ "Monomial" replaces the Schur basis with the monomial symmetric functions $m_\lambda$; multiplication is implemented by round-tripping through the Schur basis using Kostka numbers (kostkaNumber, toM).

i50 : Sp = schurRing(QQ, sp, 3, GroupActing => "Sp");
i51 : sp_{1} * sp_{1}

o51 = sp  + sp    + sp
        2     1,1     ()

o51 : Sp
i52 : O = schurRing(QQ, o, 4, GroupActing => "O");
i53 : o_{1} * o_{2}

o53 = o  + o    + o
       3    2,1    1

o53 : O
i54 : Rat = schurRing(QQ, r, 3, GroupActing => "RatGL");
i55 : r_{{1},{1}} * r_{{1},{}}

o55 = r           + r              + r
       {{2}, {1}}    {{1, 1}, {1}}    {{1}, {}}

o55 : Rat
i56 : Mon = schurRing(QQ, m, 4, Basis => "Monomial");
i57 : m_{1} * m_{1}

o57 = m  + 2m
       2     1,1

o57 : Mon

Stable vs.\ finite-rank rings. Each of the above flavors comes in two sizes. Passing a positive integer n to schurRing constructs the finite-rank ring, where partitions are restricted in length (to $n$ for GL/Sn and to the appropriate rank for Sp/O/RatGL) and the Sam-Snowden-Weyman modification rules are applied automatically. Passing infinity instead constructs the stable (universal) ring: a polynomial ring with countably many generators, one for each partition, on which all operations are performed without modification. This is the ring of universal characters of Koike--Terada — a single computation that specializes to every finite rank.

i58 : StabGL = schurRing(QQ, sg, infinity);
i59 : StabSp = schurRing(QQ, tp, infinity, GroupActing => "Sp");
i60 : tp_{1,1} * tp_{1,1}

o60 = tp    + tp      + tp  + tp        + tp    + tp
        2,2     2,1,1     2     1,1,1,1     1,1     ()

o60 : StabSp

Having computed in the stable ring, one can specialize to a finite rank at the end. The modification rule drops or re-signs any partition that exceeds the target rank.

i61 : f = tp_{1,1} * tp_{1,1};
i62 : specialize(f, 2)     -- inside Sp(4)

o62 = spfin2    + spfin2  + spfin2    + spfin2
            2,2         2         1,1         ()

o62 : schurRing (QQ, spfin2, 2)
i63 : specialize(f, 3)     -- inside Sp(6)

o63 = spfin3    + spfin3      + spfin3  + spfin3    + spfin3
            2,2         2,1,1         2         1,1         ()

o63 : schurRing (QQ, spfin3, 3)

Conversions between variants. Every basis conversion is reversible and functorial. The table below summarizes the user-level commands for moving between them:

$\bullet$ toS, toGL: to the plain Schur (GL) basis.

$\bullet$ toE, toH, toP: to the $e/h/p$-basis (lives in the associated symmetricRing).

$\bullet$ toSymm: inverse of toS; pushes a Schur-basis element into the symmetric ring.

$\bullet$ toM: to the monomial basis.

$\bullet$ toSp, toO: to the symplectic or orthogonal character basis, via the inverse Koike branching formulas.

$\bullet$ toRatGL: embeds a (polynomial) GL character into the ring of rational GL characters.

$\bullet$ toSn: carries coefficient data from a GL-style ring into an Sn-style ring (same partition labels, different product).

$\bullet$ convert: a universal dispatcher — given any source and any target, it picks the right converter.

$\bullet$ specialize: stable ring $\to$ finite-rank ring, for any variant (applies the appropriate modification rule).

$\bullet$ branch: restricts a Schur, Sp, or O character along the diagonal of a product of two classical groups.

i64 : S = schurRing(QQ, s, 5);
i65 : Sp = schurRing(QQ, sp, 2, GroupActing => "Sp");
i66 : convert(s_{2,1}, Sp)

o66 = sp    + sp
        2,1     1

o66 : Sp
i67 : convert(oo, S)

o67 = s
       2,1

o67 : S

The compatibility of these conversions can be verified against the Newell-Littlewood product directly. For instance, in the stable symplectic ring, $sp_{(1)}^2 = sp_{(2)} + sp_{(1,1)} + 1$; equivalently, $(s_{(1)})^2 = s_{(2)} + s_{(1,1)}$, and expanding each Schur function in the Sp basis via toSp and adding yields the same element.

Mathematical background. We collect some pointers for readers who wish to consult the original sources.

$\bullet$ Schur-Weyl duality states that the group algebras of $GL_n$ and $S_d$ act on $V^{\otimes d}$ with mutually centralizing images, so the decomposition of $V^{\otimes d}$ as a $GL_n \times S_d$-module provides a bijection between polynomial representations of $GL_n$ of degree $d$ and representations of $S_d$. The toSn / toGL pair is the computational realization of this bijection.

$\bullet$ The Frobenius characteristic identifies the representation ring of $S_n$ with the degree-$n$ component of the ring of symmetric functions. Under this isomorphism, the character of a virtual representation corresponds to a symmetric function, and the internal product of characters to a product expressible in the power-sum basis. See classFunction and symmetricFunction.

$\bullet$ The Koike-Terada universal characters provide a single family of symmetric functions whose specializations at $n$ variables recover the irreducible characters of $Sp(2n)$ (or $O(n)$) for every $n$. Equivalently, the stable Sp/O character rings form a purely combinatorial object, and the Sam-Snowden-Weyman modification rule tells us how to specialize to finite rank.

$\bullet$ The Newell-Littlewood product is the multiplication in the stable Sp/O ring, expressed as a Littlewood-Richardson-like sum: $$sp_\mu \cdot sp_\nu = \sum_{\alpha,\beta,\gamma} c^\mu_{\alpha,\beta}\, c^\nu_{\alpha,\gamma}\, sp_{\beta\gamma},$$ where $c^\lambda_{\mu\nu}$ are the Littlewood-Richardson coefficients. The analogous formula holds for $o$. Our implementation replaces this with the equivalent route (Schur basis, multiply, back to Sp/O via toSp/toO), which is both faster and easier to certify.

$\bullet$ King branching formulas describe the restriction of a character of a classical group to a two-factor subgroup. See branch.

$\bullet$ Plethysm $f[g]$ encodes composition of Schur functors: $f[g]$ is the character of the $GL(V)$-representation obtained by applying the functor with character $f$ to the representation with character $g$. Our implementation agrees with the classical definition on power-sum generators: $p_n[g(x_1,x_2,\dots)] = g(x_1^n, x_2^n, \dots)$. See plethysm.

References.

$\bullet$ I.\ G.\ Macdonald, Symmetric Functions and Hall Polynomials, 2nd ed., Oxford University Press, 1995.

$\bullet$ W.\ Fulton, Young Tableaux, LMSST 35, Cambridge University Press, 1997.

$\bullet$ W.\ Fulton and J.\ Harris, Representation Theory. A First Course, GTM 129, Springer, 1991.

$\bullet$ R.\ P.\ Stanley, Enumerative Combinatorics, Vol.\ 2, Cambridge University Press, 1999.

$\bullet$ B.\ E.\ Sagan, The Symmetric Group. Representations, Combinatorial Algorithms, and Symmetric Functions, 2nd ed., GTM 203, Springer, 2001.

$\bullet$ J.\ Weyman, Cohomology of Vector Bundles and Syzygies, Cambridge Tracts in Math.\ 149, 2003.

$\bullet$ K.\ Koike, On the decomposition of tensor products of the representations of classical groups: by means of universal characters, Adv.\ Math.\ 74 (1989), 57–86.

$\bullet$ K.\ Koike and I.\ Terada, Young-diagrammatic methods for the representation theory of the classical groups of type $B_n$, $C_n$, $D_n$, J.\ Algebra 107 (1987), 466–511.

$\bullet$ R.\ C.\ King, Branching rules for classical Lie groups using tensor and spinor methods, J.\ Phys.\ A 8 (1975), 429–449.

$\bullet$ S.\ V.\ Sam and A.\ Snowden, Introduction to twisted commutative algebras, arXiv:1209.5122 (2012).

$\bullet$ S.\ V.\ Sam and A.\ Snowden, Stability patterns in representation theory, Forum Math.\ Sigma 3 (2015), e11.

$\bullet$ S.\ V.\ Sam, A.\ Snowden, and J.\ Weyman, Homology of Littlewood complexes, Selecta Math.\ (N.S.) 19 (2013), 655–698.

Authors

Version

This documentation describes version 2.0 of SchurRings, released April 17, 2026.

Citation

If you have used this package in your research, please cite it as follows:

@misc{SchurRingsSource,
  title = {{SchurRings: representation rings of general linear groups and of symmetric groups. Version~2.0}},
  author = {Michael Stillman and Hal Schenck and Claudiu Raicu and Keller VandeBogert},
  howpublished = {A \emph{Macaulay2} package available at
    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}
}

Exports

  • Types
  • Functions and commands
    • branch -- Restrict a Schur, Sp, or O character along a two-factor subgroup
    • centralizerSize -- Size of the centralizer of a permutation
    • classFunction -- Converts symmetric function to class function
    • convert -- Universal dispatcher for converting between Schur ring flavors
    • internalProduct -- Internal product of symmetric functions/class functions
    • jacobiTrudi -- Jacobi-Trudi determinant
    • kostkaNumber -- Compute a Kostka number
    • modificationRule -- Apply the Sam-Snowden-Weyman modification rule
    • plethysm -- Plethystic operations on representations
    • scalarProduct -- Standard pairing on symmetric functions/class functions
    • schurLevel -- Number of SchurRings the ring is a tensor product of.
    • schurResolution -- Compute an ``approximate'' equivariant resolution of a module.
    • schurRing -- Make a SchurRing
    • specialize -- Specialize a stable character to a finite rank
    • symmetricFunction -- Converts class function to symmetric function
    • symmetricRing -- Make a Symmetric ring
    • toE -- Elementary symmetric (e-) basis representation
    • toGL -- Express an element in the plain GL Schur basis
    • toH -- Complete symmetric (h-) basis representation
    • toM -- Monomial (m-) basis representation
    • toO -- Expansion in the basis of orthogonal characters
    • toP -- Power-sum (p-) basis representation
    • toRatGL -- Lift a Schur (GL, SL) character into a rational-GL Schur ring
    • toS -- Schur (s-) basis representation
    • toSn -- Promote a Schur-basis element into an Sn character ring
    • toSp -- Expansion in the basis of symplectic characters
    • toSymm -- Convert a Schur ring element to an element of the associated symmetric ring
  • Methods
    • branch(RingElement,SchurRing,SchurRing) -- see branch -- Restrict a Schur, Sp, or O character along a two-factor subgroup
    • branch(RingElement,ZZ,ZZ) -- see branch -- Restrict a Schur, Sp, or O character along a two-factor subgroup
    • centralizerSize(List) -- see centralizerSize -- Size of the centralizer of a permutation
    • ClassFunction * ClassFunction -- see ClassFunction -- The class of all Class functions
    • ClassFunction * Number -- see ClassFunction -- The class of all Class functions
    • ClassFunction * RingElement -- see ClassFunction -- The class of all Class functions
    • ClassFunction + ClassFunction -- see ClassFunction -- The class of all Class functions
    • ClassFunction - ClassFunction -- see ClassFunction -- The class of all Class functions
    • ClassFunction == ClassFunction -- see ClassFunction -- The class of all Class functions
    • Number * ClassFunction -- see ClassFunction -- The class of all Class functions
    • RingElement * ClassFunction -- see ClassFunction -- The class of all Class functions
    • classFunction(RingElement) -- see classFunction -- Converts symmetric function to class function
    • classFunction(BasicList) -- Character of irreducible representation of symmetric group
    • coefficientRing(SchurRing) -- Coefficient ring of a Schur ring
    • convert(RingElement,Ring) -- see convert -- Universal dispatcher for converting between Schur ring flavors
    • convert(Number,Ring) (missing documentation)
    • degree(ClassFunction) -- Degree of virtual character
    • dim(List,SchurRingElement) -- dimension of representation
    • dim(SchurRingElement) -- see dim(List,SchurRingElement) -- dimension of representation
    • dim(Thing,SchurRingElement) -- see dim(List,SchurRingElement) -- dimension of representation
    • internalProduct(ClassFunction,ClassFunction) -- Tensor product of virtual representations
    • internalProduct(RingElement,RingElement) -- Kronecker product of symmetric functions
    • jacobiTrudi(BasicList,Ring) -- see jacobiTrudi -- Jacobi-Trudi determinant
    • kostkaNumber(BasicList,BasicList) -- see kostkaNumber -- Compute a Kostka number
    • numgens(SchurRing) -- Number of generators of Schur ring.
    • partitions(Set,BasicList) -- Partitions of a set
    • plethysm(RingElement,RingElement) -- see plethysm -- Plethystic operations on representations
    • plethysm(BasicList,RingElement) -- Plethystic operations on representations
    • plethysm(BasicList,ClassFunction) -- see plethysm(RingElement,ClassFunction) -- Plethystic operations on class functions
    • plethysm(RingElement,ClassFunction) -- Plethystic operations on class functions
    • scalarProduct(ClassFunction,ClassFunction) -- Standard scalar product of class functions
    • scalarProduct(RingElement,RingElement) -- Standard scalar product of symmetric functions
    • schurLevel(Ring) -- see schurLevel -- Number of SchurRings the ring is a tensor product of.
    • schurResolution(RingElement,List) -- see schurResolution -- Compute an ``approximate'' equivariant resolution of a module.
    • schurResolution(RingElement,List,List) -- see schurResolution -- Compute an ``approximate'' equivariant resolution of a module.
    • SchurRing _ List -- see SchurRing -- The class of all Schur rings
    • SchurRing _ Sequence -- see SchurRing -- The class of all Schur rings
    • SchurRing _ ZZ -- see SchurRing -- The class of all Schur rings
    • schurRing(Ring,Symbol) -- see schurRing -- Make a SchurRing
    • 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
    • schurRing(Thing) -- see schurRing -- Make a SchurRing
    • schurRing(Thing,ZZ) -- see schurRing -- Make a SchurRing
    • schurRing(Ring) -- The Schur ring corresponding to a given Symmetric ring.
    • SchurRingIndexedVariableTable _ Thing -- see SchurRingIndexedVariableTable
    • specialize(RingElement,List) -- see specialize -- Specialize a stable character to a finite rank
    • specialize(RingElement,ZZ) -- see specialize -- Specialize a stable character to a finite rank
    • specialize(RingElement,ZZ,SchurRing) (missing documentation)
    • symmetricFunction(ClassFunction,Ring) -- see symmetricFunction -- Converts class function to symmetric function
    • symmetricRing(Ring,ZZ) -- see symmetricRing -- Make a Symmetric ring
    • symmetricRing(ZZ) -- see symmetricRing -- Make a Symmetric ring
    • symmetricRing(Ring) -- The Symmetric ring corresponding to a given (Schur) ring.
    • toE(RingElement) -- see toE -- Elementary symmetric (e-) basis representation
    • toGL(RingElement) -- see toGL -- Express an element in the plain GL Schur basis
    • toGL(RingElement,SchurRing) -- see toGL -- Express an element in the plain GL Schur basis
    • toH(RingElement) -- see toH -- Complete symmetric (h-) basis representation
    • toM(RingElement) -- see toM -- Monomial (m-) basis representation
    • toM(RingElement,SchurRing) -- see toM -- Monomial (m-) basis representation
    • toO(RingElement) -- see toO -- Expansion in the basis of orthogonal characters
    • toO(RingElement,SchurRing) -- see toO -- Expansion in the basis of orthogonal characters
    • toP(RingElement) -- see toP -- Power-sum (p-) basis representation
    • toRatGL(RingElement,SchurRing) -- see toRatGL -- Lift a Schur (GL, SL) character into a rational-GL Schur ring
    • toRatGL(RingElement) (missing documentation)
    • toS(RingElement) -- see toS -- Schur (s-) basis representation
    • 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) -- see toSp -- Expansion in the basis of symplectic characters
    • toSp(RingElement,SchurRing) -- see toSp -- Expansion in the basis of symplectic characters
    • toSymm(Number) -- see toSymm -- Convert a Schur ring element to an element of the associated symmetric ring
    • toSymm(RingElement) -- see toSymm -- Convert a Schur ring element to an element of the associated symmetric ring
  • Symbols
    • Basis -- Specifies the basis to use for a Schur ring
    • EHPVariables -- Specifies sequence of symbols representing e-, h-, and p-functions
    • EorH -- e- or h- representation of Jacobi-Trudi determinant
    • eVariable -- Elementary symmetric functions in a Symmetric ring
    • GroupActing -- Specifies the group that is acting
    • hVariable -- Complete symmetric functions in a Symmetric ring
    • Memoize -- Option to record values of the jacobiTrudi function
    • OddOrEven -- Select type $B_n$ or type $D_n$ for an orthogonal Schur ring
    • pVariable -- Power-sum symmetric functions in a Symmetric ring
    • SVariable -- Specifies symbol representing s-functions

For the programmer

The object SchurRings is a package, defined in SchurRings.m2.


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