This is SchurRings.info, produced by Macaulay2, version 1.24.11

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 (Macaulay2Doc), 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 (Macaulay2Doc),:

+----------+
|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 (Macaulay2Doc),
and exteriorPower (Macaulay2Doc),:

+-----------------------------+
|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 @ (Macaulay2Doc), 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 * (Macaulay2Doc).

+-------------+
|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, see 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                         |
+-----------------------------------+

Authors
=======

  * Michael Stillman (see http://www.math.cornell.edu/~mike/ )
    <mike@math.cornell.edu>
  * Hal Schenck
  * Claudiu Raicu (see http://math.berkeley.edu/~claudiu/ )
    <claudiu@math.berkeley.edu>

Version
=======

This documentation describes version 1.1 of SchurRings.

Source code
===========

The source code from which this documentation is derived is in the file
SchurRings.m2 (see common/share/Macaulay2/SchurRings.m2 ).

Exports
=======

  * Types
      * ClassFunction -- The class of all Class functions
      * SchurRing -- The class of all Schur rings
      * SchurRingElement -- A type describing elements
        of a SchurRing
      * SchurRingIndexedVariableTable
  * Functions and commands
      * centralizerSize -- Size of the centralizer of a
        permutation
      * classFunction -- Converts symmetric function to
        class function
      * internalProduct -- Internal product of
        symmetric functions/class functions
      * jacobiTrudi -- Jacobi-Trudi determinant
      * 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
      * symmetricFunction -- Converts class function
        to symmetric function
      * symmetricRing -- Make a Symmetric ring
      * toE -- Elementary symmetric (e-) basis representation
      * toH -- Complete symmetric (h-) basis representation
      * toP -- Power-sum (p-) basis representation
      * toS -- Schur (s-) basis representation
  * Methods
      * "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
      * 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
      * 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,
      * "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
      * "toH(RingElement)" -- see toH, -- Complete symmetric (h-)
        basis representation
      * "toP(RingElement)" -- see toP, -- Power-sum (p-) basis
        representation
      * "toS(RingElement)" -- see toS, -- Schur (s-) basis
        representation
      * "toS(RingElement,SchurRing)" -- see toS, -- Schur (s-) basis
        representation
  * Symbols
      * 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
      * pVariable -- Power-sum symmetric functions in a
        Symmetric ring
      * SVariable -- Specifies symbol representing
        s-functions

For the programmer
==================

The object SchurRings, is a package (Macaulay2Doc).

centralizerSize -- Size of the centralizer of a permutation
***********************************************************

Synopsis
========

  * Usage:
        n = centralizerSize(rho)
  * Inputs:
      * rho, a list (Macaulay2Doc),
  * Outputs:
      * n, an integer (Macaulay2Doc),

Description
===========

rho is a list representing the cycle type of some permutation: the i-th entry
in rho is the number of cycles of length i of the permutation. The output of
the function centralizerSize is the size of the centralizer in the symmetric
group of any permutation of cycle type rho. The cycle type rho corresponds to a
partition lambda, in which case centralizerSize(rho) is also the value of the
square norm of the symmetric function p_{lambda}.

+-----------------------------+
|i1 : centralizerSize{1,1,1}  |
|                             |
|o1 = 6                       |
+-----------------------------+
|i2 : R = symmetricRing(QQ,6);|
+-----------------------------+
|i3 : u = p_1 * p_2 * p_3;    |
+-----------------------------+
|i4 : scalarProduct(u,u)      |
|                             |
|o4 = 6                       |
|                             |
|o4 : QQ                      |
+-----------------------------+

Ways to use centralizerSize:
============================

  * "centralizerSize(List)"

For the programmer
==================

The object centralizerSize, is a method function (Macaulay2Doc).

ClassFunction -- The class of all Class functions
*************************************************

Description
===========

A class function (or virtual character of a symmetric group S_n) is a function
that is constant on the conjugacy classes of S_n. Class functions for S_n are
in one to one correspondence with symmetric functions of degree n. The class
functions corresponding to actual representations of S_n are called characters.

The character of the standard representation of S_3 is

+----------------------------------+
|i1 : S = schurRing(QQ,s,3);       |
+----------------------------------+
|i2 : classFunction(s_{2,1})       |
|                                  |
|o2 = ClassFunction{{1, 1, 1} => 2}|
|                   {3} => -1      |
|                                  |
|o2 : ClassFunction                |
+----------------------------------+

The character of the sign representation of S_5 is

+----------------------------------------+
|i3 : S = schurRing(QQ,s,5);             |
+----------------------------------------+
|i4 : classFunction(s_{1,1,1,1,1})       |
|                                        |
|o4 = ClassFunction{{1, 1, 1, 1, 1} => 1}|
|                   {2, 1, 1, 1} => -1   |
|                   {2, 2, 1} => 1       |
|                   {3, 1, 1} => 1       |
|                   {3, 2} => -1         |
|                   {4, 1} => -1         |
|                   {5} => 1             |
|                                        |
|o4 : ClassFunction                      |
+----------------------------------------+

We can go back and forth between class functions and symmetric functions.

+-----------------------------------------------------------+
|i5 : R = symmetricRing(QQ,3);                              |
+-----------------------------------------------------------+
|i6 : cF = new ClassFunction from {{1,1,1} => 2, {3} => -1};|
+-----------------------------------------------------------+
|i7 : sF = symmetricFunction(cF,R)                          |
|                                                           |
|     1 3   1                                               |
|o7 = -p  - -p                                              |
|     3 1   3 3                                             |
|                                                           |
|o7 : R                                                     |
+-----------------------------------------------------------+
|i8 : toS sF                                                |
|                                                           |
|o8 = s                                                     |
|      2,1                                                  |
|                                                           |
|o8 : schurRing (QQ, s, 3)                                  |
+-----------------------------------------------------------+
|i9 : classFunction sF                                      |
|                                                           |
|o9 = ClassFunction{{1, 1, 1} => 2}                         |
|                   {3} => -1                               |
|                                                           |
|o9 : ClassFunction                                         |
+-----------------------------------------------------------+

We can add, subtract, multiply, scale class functions:

+------------------------------------------+
|i10 : S = schurRing(QQ,s,4);              |
+------------------------------------------+
|i11 : c1 = classFunction(S_{2,1,1}-S_{4});|
+------------------------------------------+
|i12 : c2 = classFunction(S_{3,1});        |
+------------------------------------------+
|i13 : c1 + c2                             |
|                                          |
|o13 = ClassFunction{{1, 1, 1, 1} => 5}    |
|                    {2, 1, 1} => -1       |
|                    {2, 2} => -3          |
|                    {3, 1} => -1          |
|                    {4} => -1             |
|                                          |
|o13 : ClassFunction                       |
+------------------------------------------+
|i14 : c1 * c2                             |
|                                          |
|o14 = ClassFunction{{1, 1, 1, 1} => 6}    |
|                    {2, 1, 1} => -2       |
|                    {2, 2} => 2           |
|                                          |
|o14 : ClassFunction                       |
+------------------------------------------+
|i15 : 3*c1 - c2*2                         |
|                                          |
|o15 = ClassFunction{{2, 1, 1} => -8}      |
|                    {2, 2} => -4          |
|                    {3, 1} => -3          |
|                    {4} => 2              |
|                                          |
|o15 : ClassFunction                       |
+------------------------------------------+

Methods that use a Class function:
==================================

  * "ClassFunction * ClassFunction"
  * "ClassFunction * Number"
  * "ClassFunction * RingElement"
  * "ClassFunction + ClassFunction"
  * "ClassFunction - ClassFunction"
  * "ClassFunction == ClassFunction"
  * "Number * ClassFunction"
  * "RingElement * ClassFunction"
  * degree(ClassFunction) -- Degree of
    virtual character
  * internalProduct(ClassFunction,ClassFunction)
    -- Tensor product of
    virtual 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
  * "symmetricFunction(ClassFunction,Ring)" -- see symmetricFunction,
    -- Converts class function to symmetric function

For the programmer
==================

The object ClassFunction, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

classFunction -- Converts symmetric function to class function
**************************************************************

Synopsis
========

  * Usage:
        ch = classFunction(f)
  * Inputs:
      * f, a ring element (Macaulay2Doc), element of a
        Symmetric ring
  * Outputs:
      * ch, a Class function,

Description
===========

Given a symmetric function f, homogeneous of degree N, the method computes the
corresponding virtual character of the symmetric group S_N.

The character of the standard representation of S_5 is

+----------------------------------------+
|i1 : R = symmetricRing(QQ,5);           |
+----------------------------------------+
|i2 : classFunction(jacobiTrudi({4,1},R))|
|                                        |
|o2 = ClassFunction{{1, 1, 1, 1, 1} => 4}|
|                   {2, 1, 1, 1} => 2    |
|                   {3, 1, 1} => 1       |
|                   {3, 2} => -1         |
|                   {5} => -1            |
|                                        |
|o2 : ClassFunction                      |
+----------------------------------------+

The character of the second exterior power of the standard representation of
S_5 is

+------------------------------------------+
|i3 : R = symmetricRing(QQ,5);             |
+------------------------------------------+
|i4 : classFunction(jacobiTrudi({3,1,1},R))|
|                                          |
|o4 = ClassFunction{{1, 1, 1, 1, 1} => 6}  |
|                   {2, 2, 1} => -2        |
|                   {5} => 1               |
|                                          |
|o4 : ClassFunction                        |
+------------------------------------------+

See also
========

  * symmetricFunction -- Converts class function to
    symmetric function

Ways to use classFunction:
==========================

  * "classFunction(RingElement)"
  * classFunction(BasicList) -- Character
    of irreducible representation of symmetric group

For the programmer
==================

The object classFunction, is a method function (Macaulay2Doc).

classFunction(BasicList) -- Character of irreducible representation of symmetric group
**************************************************************************************

Synopsis
========

  * Function: classFunction,
  * Usage:
        ch = classFunction(l)
  * Inputs:
      * l, a basic list (Macaulay2Doc), partition
  * Outputs:
      * ch, a Class function,

Description
===========

Given a partition l of N, the method computes the character of the irreducible
S_N-representation corresponding to the partition l.

+--------------------------------------------+
|i1 : R = symmetricRing(QQ,7);               |
+--------------------------------------------+
|i2 : cF = classFunction({3,2,1})            |
|                                            |
|o2 = ClassFunction{{1, 1, 1, 1, 1, 1} => 16}|
|                   {3, 1, 1, 1} => -2       |
|                   {3, 3} => -2             |
|                   {5, 1} => 1              |
|                                            |
|o2 : ClassFunction                          |
+--------------------------------------------+
|i3 : toS(symmetricFunction(cF,R))           |
|                                            |
|o3 = s                                      |
|      3,2,1                                 |
|                                            |
|o3 : schurRing (QQ, s, 7)                   |
+--------------------------------------------+

See also
========

  * symmetricFunction -- Converts class function to
    symmetric function

Ways to use this method:
========================

  * classFunction(BasicList) -- Character
    of irreducible representation of symmetric group

coefficientRing(SchurRing) -- Coefficient ring of a Schur ring
**************************************************************

Synopsis
========

  * Function: coefficientRing (Macaulay2Doc),
  * Usage:
        coefficientRing S
  * Inputs:
      * S, a Schur ring,
  * Outputs:
      * a ring (Macaulay2Doc),

Description
===========

Given a Schur ring S, the function returns its coefficient ring.

+------------------------------+
|i1 : S = schurRing(ZZ[x],s,4);|
+------------------------------+
|i2 : coefficientRing S        |
|                              |
|o2 = ZZ[x]                    |
|                              |
|o2 : PolynomialRing           |
+------------------------------+
|i3 : A = schurRing(QQ,a,3);   |
+------------------------------+
|i4 : B = schurRing(A,b,2);    |
+------------------------------+
|i5 : coefficientRing B        |
|                              |
|o5 = A                        |
|                              |
|o5 : SchurRing                |
+------------------------------+

Ways to use this method:
========================

  * coefficientRing(SchurRing), --
    Coefficient ring of a Schur ring

degree(ClassFunction) -- Degree of virtual character
****************************************************

Synopsis
========

  * Function: degree (Macaulay2Doc),

Description
===========

For a virtual character ch of a symmetric group on n letters, the degree of ch
is n.

+----------------------------------------+
|i1 : S = schurRing(s,5);                |
+----------------------------------------+
|i2 : ch = classFunction s_(3,1,1)       |
|                                        |
|o2 = ClassFunction{{1, 1, 1, 1, 1} => 6}|
|                   {2, 2, 1} => -2      |
|                   {5} => 1             |
|                                        |
|o2 : ClassFunction                      |
+----------------------------------------+
|i3 : degree ch                          |
|                                        |
|o3 = 5                                  |
+----------------------------------------+

Ways to use this method:
========================

  * degree(ClassFunction) -- Degree of
    virtual character

dim(List,SchurRingElement) -- dimension of representation
*********************************************************

Synopsis
========

  * Function: dim (Macaulay2Doc),
  * Usage:
        d = dim(lis,s)
        d = dim(n,s)
        d = dim s
  * Inputs:
      * lis, a list (Macaulay2Doc), or Thing (Macaulay2Doc),
      * s, an instance of the type SchurRingElement,
  * Outputs:
      * d, an integer (Macaulay2Doc), or Expression (Macaulay2Doc),

Description
===========

The method returns the dimension of the virtual representation whose character
is represented by s.

+-------------------------------------------+
|i1 : S = schurRing(s,3)                    |
|                                           |
|o1 = S                                     |
|                                           |
|o1 : SchurRing                             |
+-------------------------------------------+
|i2 : dim s_2                               |
|                                           |
|o2 = 6                                     |
+-------------------------------------------+
|i3 : T = schurRing(t,4,GroupActing => "Sn")|
|                                           |
|o3 = T                                     |
|                                           |
|o3 : SchurRing                             |
+-------------------------------------------+
|i4 : dim t_{2,2}                           |
|                                           |
|o4 = 2                                     |
+-------------------------------------------+
|i5 : U = schurRing(T,u,3)                  |
|                                           |
|o5 = U                                     |
|                                           |
|o5 : SchurRing                             |
+-------------------------------------------+
|i6 : dim (t_{2,2}*u_2)                     |
|                                           |
|o6 = 12                                    |
+-------------------------------------------+

If S is a SchurRing, of level 1, the ring of polynomial
representations of some GL(V), it may sometimes be convenient to compute
dimensions of GL(V)-representations symbolically, without specifying the
dimension of V. Letting n denote the parameter corresponding to dim(V) we have
for example

+--------------------------------+
|i7 : S = schurRing(s,3)         |
|                                |
|o7 = S                          |
|                                |
|o7 : SchurRing                  |
+--------------------------------+
|i8 : dim(n,s_2)                 |
|                                |
|     n(n + 1)                   |
|o8 = --------                   |
|         2                      |
|                                |
|o8 : Expression of class Divide |
+--------------------------------+
|i9 : dim(n,s_{1,1})             |
|                                |
|     (n - 1)n                   |
|o9 = --------                   |
|         2                      |
|                                |
|o9 : Expression of class Divide |
+--------------------------------+
|i10 : dim(n,s_{2,1})            |
|                                |
|      (n - 1)n(n + 1)           |
|o10 = ---------------           |
|             3                  |
|                                |
|o10 : Expression of class Divide|
+--------------------------------+

Similar calculations make sense over products of general linear groups. The
dimensions of the representations can be computed symbolically as functions of
a number of parameters equal to the schurLevel, of the ring.
The parameters corresponding to levels where the group acting is a symmetric
group don't have a good interpretation, so they are disregarded in the
dimension calculation. The order of the input parameters is the descending
order of the schurLevel,s: in the example below a corresponds
to Q, b corresponds to T and c corresponds to S.

+------------------------------------------------+
|i11 : S = schurRing(s,3)                        |
|                                                |
|o11 = S                                         |
|                                                |
|o11 : SchurRing                                 |
+------------------------------------------------+
|i12 : T = schurRing(S,t,4)                      |
|                                                |
|o12 = T                                         |
|                                                |
|o12 : SchurRing                                 |
+------------------------------------------------+
|i13 : Q = schurRing(T,q,5,GroupActing => "Sn")  |
|                                                |
|o13 = Q                                         |
|                                                |
|o13 : SchurRing                                 |
+------------------------------------------------+
|i14 : dExpr = dim({a,b,c},s_{2}*t_{1,1}*q_{4,1})|
|                                                |
|      c(c + 1) (b - 1)b                         |
|o14 = --------*--------*4                       |
|          2        2                            |
|                                                |
|o14 : Expression of class Product               |
+------------------------------------------------+
|i15 : P = QQ[a,b,c]                             |
|                                                |
|o15 = P                                         |
|                                                |
|o15 : PolynomialRing                            |
+------------------------------------------------+
|i16 : value dExpr                               |
|                                                |
|       2 2    2       2                         |
|o16 = b c  + b c - b*c  - b*c                   |
|                                                |
|o16 : P                                         |
+------------------------------------------------+
|i17 : dim({1,2,3},s_{2}*t_{1,1}*q_{4,1})        |
|                                                |
|o17 = 24                                        |
|                                                |
|o17 : QQ                                        |
+------------------------------------------------+

Ways to use this method:
========================

  * dim(List,SchurRingElement), --
    dimension of representation
  * "dim(SchurRingElement)"
  * "dim(Thing,SchurRingElement)"

EHPVariables -- Specifies sequence of symbols representing e-, h-, and p-functions
**********************************************************************************

Description
===========

This is an optional argument for the constructor of a Symmetric or Schur ring.
It indicates the symbols to be used to denote e-, h-, and p-functions in the
associated Symmetric ring. The default values are (e,h,p).

+-----------------------------------------------------------------------------+
|i1 : S = schurRing(QQ,s,4,EHPVariables =>                                    |
|-----------------------------------------------------------------------------|
|(getSymbol"a",getSymbol"b",getSymbol"c"));                                   |
+-----------------------------------------------------------------------------+
|i2 : R = symmetricRing S                                                     |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : epol = toE s_{2,2,2}                                                    |
|                                                                             |
|      2                                                                      |
|o3 = a  - a a                                                                |
|      3    2 4                                                               |
|                                                                             |
|o3 : R                                                                       |
+-----------------------------------------------------------------------------+
|i4 : toS epol                                                                |
|                                                                             |
|o4 = s                                                                       |
|      2,2,2                                                                  |
|                                                                             |
|o4 : S                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * SVariable -- Specifies symbol representing s-functions

Functions with optional argument named EHPVariables:
====================================================

  * "schurRing(...,EHPVariables=>...)"
  * "symmetricRing(...,EHPVariables=>...)"

For the programmer
==================

The object EHPVariables, is a symbol (Macaulay2Doc).

EorH -- e- or h- representation of Jacobi-Trudi determinant
***********************************************************

Synopsis
========

  * Usage:
        EorH => s
  * Inputs:
      * s, a string (Macaulay2Doc), either "E" or "H"

Description
===========

This option allows one to choose between evaluating the Jacobi-Trudi
determinant in the e- or h- basis. If the length of the conjugate partition
lambda' is larger than the length of lambda, then it is computationally less
expensive to set the option EorH to "H". Otherwise, the default value "E" is
more efficient.

Functions with optional argument named EorH:
============================================

  * "jacobiTrudi(...,EorH=>...)"

For the programmer
==================

The object EorH, is a symbol (Macaulay2Doc).

eVariable -- Elementary symmetric functions in a Symmetric ring
***************************************************************

Description
===========

For a Symmetric ring R of dimension n, R.eVariable is a function which assigns
to each index 1\leq i\leq n the i-th elementary symmetric function. If i is
outside the given bounds, an error is returned.

+-----------------------------------------------------+
|i1 : R = symmetricRing(QQ,5,EHPVariables => (a,b,c));|
+-----------------------------------------------------+
|i2 : R.eVariable 3                                   |
|                                                     |
|o2 = a                                               |
|      3                                              |
|                                                     |
|o2 : R                                               |
+-----------------------------------------------------+

See also
========

  * hVariable -- Complete symmetric functions in a Symmetric
    ring
  * pVariable -- Power-sum symmetric functions in a Symmetric
    ring

For the programmer
==================

The object eVariable, is a symbol (Macaulay2Doc).

GroupActing -- Specifies the group that is acting
*************************************************

Description
===========

This is an optional argument for the schurRing, and
symmetricRing, functions. When the exterior or symmetric powers
of a symmetric function g are computed, the result depends on whether g is
interpreted as a virtual representation of a general linear or symmetric group.
The option GroupActing specifies the interpretation to be considered. Its
possible values are "GL" and "Sn", with the former being the default.

+--------------------------------------------+
|i1 : S = schurRing(s,2);                    |
+--------------------------------------------+
|i2 : exteriorPower(3,s_2)                   |
|                                            |
|o2 = s                                      |
|      3,3                                   |
|                                            |
|o2 : S                                      |
+--------------------------------------------+
|i3 : T = schurRing(t,2,GroupActing => "Sn");|
+--------------------------------------------+
|i4 : symmetricPower(2,t_{1,1})              |
|                                            |
|o4 = t                                      |
|      2                                     |
|                                            |
|o4 : T                                      |
+--------------------------------------------+

The first example computes the decomposition of \Lambda^3(Sym^2(V)) into
irreducible GL(V)-representations, while the second one computes the second
symmetric power of the sign representation of the symmetric group S_2.

Functions with optional argument named GroupActing:
===================================================

  * "schurRing(...,GroupActing=>...)"
  * "symmetricRing(...,GroupActing=>...)"

For the programmer
==================

The object GroupActing, is a symbol (Macaulay2Doc).

hVariable -- Complete symmetric functions in a Symmetric ring
*************************************************************

Description
===========

For a Symmetric ring R of dimension n, R.hVariable is a function which assigns
to each index 1\leq i\leq n the i-th complete symmetric function. If i is
outside the given bounds, an error is returned.

+-----------------------------------------------------+
|i1 : R = symmetricRing(QQ,2,EHPVariables => (x,y,z));|
+-----------------------------------------------------+
|i2 : R.hVariable 2                                   |
|                                                     |
|o2 = y                                               |
|      2                                              |
|                                                     |
|o2 : R                                               |
+-----------------------------------------------------+

See also
========

  * eVariable -- Elementary symmetric functions in a
    Symmetric ring
  * pVariable -- Power-sum symmetric functions in a Symmetric
    ring

For the programmer
==================

The object hVariable, is a symbol (Macaulay2Doc).

internalProduct -- Internal product of symmetric functions/class functions
**************************************************************************

Description
===========

This method computes the internal (Kronecker) product of two homogeneous
symmetric functions of the same degree. If we think of these functions as being
virtual characters of some symmetric group, then their internal product is just
the character of the tensor product of the corresponding virtual
representations. We use the binary operator ** (Macaulay2Doc), as
a shorthand for internalProduct.

The complete symmetric function of degree n corresponds to the trivial
S_n-representation and is therefore the unit of the representation ring of S_n:

+---------------------------------+
|i1 : R = symmetricRing(QQ,5);    |
+---------------------------------+
|i2 : S = schurRing(QQ,s,3);      |
+---------------------------------+
|i3 : internalProduct(h_3,s_{2,1})|
|                                 |
|o3 = s                           |
|      2,1                        |
|                                 |
|o3 : S                           |
+---------------------------------+
|i4 : toE(h_3 ** e_3)             |
|                                 |
|o4 = e                           |
|      3                          |
|                                 |
|o4 : QQ[e ..e , p ..p , h ..h ]  |
|         1   3   1   3   1   3   |
+---------------------------------+

The square of the sign representation is the trivial representation:

+---------------------------------+
|i5 : R = symmetricRing(QQ,5);    |
+---------------------------------+
|i6 : toH internalProduct(e_3,e_3)|
|                                 |
|o6 = h                           |
|      3                          |
|                                 |
|o6 : R                           |
+---------------------------------+

See also
========

  * scalarProduct -- Standard pairing on symmetric
    functions/class functions

Ways to use internalProduct:
============================

  * internalProduct(ClassFunction,ClassFunction)
    -- Tensor product of
    virtual representations
  * internalProduct(RingElement,RingElement)
    -- Kronecker product of
    symmetric functions

For the programmer
==================

The object internalProduct, is a method function (Macaulay2Doc).

internalProduct(ClassFunction,ClassFunction) -- Tensor product of virtual representations
*****************************************************************************************

Synopsis
========

  * Function: internalProduct,
  * Usage:
        ip = internalProduct(ch1,ch2)
  * Inputs:
      * ch1, a Class function,
      * ch2, a Class function,
  * Outputs:
      * ip, a Class function,

Description
===========

Given virtual characters ch1 and ch2, the method computes the character of the
tensor product of corresponding virtual representations of the symmetric group.

+-----------------------------------------------------------------------------+
|i1 : ch1 = new ClassFunction from {{4,4} => 2, {8} => -1, {5,2,1} => 2,      |
|-----------------------------------------------------------------------------|
|{3,2,2,1} => 1};                                                             |
+-----------------------------------------------------------------------------+
|i2 : ch2 = new ClassFunction from {{2,2,2,2} => -4, {5,2,1} => 1, {3,2,2,1}  |
|-----------------------------------------------------------------------------|
|=> 3};                                                                       |
+-----------------------------------------------------------------------------+
|i3 : internalProduct(ch1,ch2)                                                |
|                                                                             |
|o3 = ClassFunction{{3, 2, 2, 1} => 3}                                        |
|                   {5, 2, 1} => 2                                            |
|                                                                             |
|o3 : ClassFunction                                                           |
+-----------------------------------------------------------------------------+
|i4 : ch1 * ch2                                                               |
|                                                                             |
|o4 = ClassFunction{{3, 2, 2, 1} => 3}                                        |
|                   {5, 2, 1} => 2                                            |
|                                                                             |
|o4 : ClassFunction                                                           |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * internalProduct(ClassFunction,ClassFunction)
    -- Tensor product of
    virtual representations

internalProduct(RingElement,RingElement) -- Kronecker product of symmetric functions
************************************************************************************

Synopsis
========

  * Function: internalProduct,
  * Usage:
        ip = internalProduct(f1,f2)
  * Inputs:
      * f1, a ring element (Macaulay2Doc), element of a
        Symmetric ring or a Schur ring
      * f2, a ring element (Macaulay2Doc), element of a
        Symmetric ring or a Schur ring
  * Outputs:
      * ip, a ring (Macaulay2Doc), a Symmetric ring or a Schur Ring

Description
===========

Given symmetric functions f1 and f2, the method computes the Kronecker product
ip between f1 and f2. The output ip is an element in the ring of f2.

+---------------------------------------------+
|i1 : R = symmetricRing(QQ,6);                |
+---------------------------------------------+
|i2 : S = schurRing(QQ,s,6);                  |
+---------------------------------------------+
|i3 : toE(h_3**e_3)                           |
|                                             |
|o3 = e                                       |
|      3                                      |
|                                             |
|o3 : R                                       |
+---------------------------------------------+
|i4 : Q = schurRing(QQ,q,6);                  |
+---------------------------------------------+
|i5 : internalProduct(s_{3,3},q_{4,2})        |
|                                             |
|o5 = q    + q      + q    + q      + q       |
|      5,1    4,1,1    3,3    3,2,1    2,2,1,1|
|                                             |
|o5 : Q                                       |
+---------------------------------------------+

An error is returned if f1 and f2 don't have the same degree.

Ways to use this method:
========================

  * internalProduct(RingElement,RingElement)
    -- Kronecker product of
    symmetric functions

jacobiTrudi -- Jacobi-Trudi determinant
***************************************

Synopsis
========

  * Usage:
        f = jacobiTrudi(lambda,R)
  * Inputs:
      * lambda, a basic list (Macaulay2Doc), a nonincreasing
        list of integers, or a partition
      * R, a ring (Macaulay2Doc), a Symmetric ring
  * Optional inputs (Macaulay2Doc),:
      * EorH, => ..., default value "E", e- or h- representation of
        Jacobi-Trudi determinant
      * Memoize, => ...,
        default value true, Store values of the jacobiTrudi function.
  * Outputs:
      * f, a ring element (Macaulay2Doc), an element of a
        Symmetric ring

Description
===========

Given a partition lambda and Symmetric ring R, the method evaluates the
Jacobi-Trudi determinant corresponding to the partition lambda, yielding a
representation of the Schur function s_{lambda} as a symmetric function in R.
The default option is to represent this symmetric function in terms of
e-polynomials.

+----------------------------------------------------------+
|i1 : R = symmetricRing(QQ,10);                            |
+----------------------------------------------------------+
|i2 : jacobiTrudi({3,2,2,1},R)                             |
|                                                          |
|               2                                          |
|o2 = e e e  - e  - e e e  + e e                           |
|      1 3 4    4    1 2 5    2 6                          |
|                                                          |
|o2 : R                                                    |
+----------------------------------------------------------+
|i3 : jacobiTrudi(new Partition from {4,4,1},R,EorH => "H")|
|                                                          |
|        2                                                 |
|o3 = h h  - h h h  - h h  + h h                           |
|      1 4    1 3 5    4 5    3 6                          |
|                                                          |
|o3 : R                                                    |
+----------------------------------------------------------+
|i4 : toS oo                                               |
|                                                          |
|o4 = s                                                    |
|      4,4,1                                               |
|                                                          |
|o4 : schurRing (QQ, s, 10)                                |
+----------------------------------------------------------+

Ways to use jacobiTrudi:
========================

  * "jacobiTrudi(BasicList,Ring)"

For the programmer
==================

The object jacobiTrudi, is a method function with options (Macaulay2Doc).

jacobiTrudi(...,Memoize=>...) -- Store values of the jacobiTrudi function.
**************************************************************************

Synopsis
========

  * Usage:
        Memoize => b
  * Inputs:
      * b, a Boolean value (Macaulay2Doc),

Description
===========

If the option is set to true then all the values of the jacobiTrudi function
that are computed are recorded into a special hash table attached to the
symmetric ring inside which the computations are done.

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Function: jacobiTrudi, -- Jacobi-Trudi determinant
  * Option key: Memoize, -- Option to record values of the
    jacobiTrudi function

Functions with optional argument named Memoize:
===============================================

  * jacobiTrudi(...,Memoize=>...)
    -- Store values of the
    jacobiTrudi function.

Memoize -- Option to record values of the jacobiTrudi function
**************************************************************

Description
===========

This is an optional argument for the jacobiTrudi, function,
allowing one to store its values in order to speed up computations.

Functions with optional argument named Memoize:
===============================================

  * jacobiTrudi(...,Memoize=>...)
    -- Store values of the
    jacobiTrudi function.

For the programmer
==================

The object Memoize, is a symbol (Macaulay2Doc).

numgens(SchurRing) -- Number of generators of Schur ring.
*********************************************************

Synopsis
========

  * Function: numgens (Macaulay2Doc),

Description
===========

Given a Schur ring S, the function numgens outputs the number of generators of
S. This is equal to the relative dimension of S over its base ring, and also to
the maximal number of parts of a partition allowed as an index for the elements
of S.

+---------------------------+
|i1 : R = schurRing(QQ,r,6);|
+---------------------------+
|i2 : numgens R             |
|                           |
|o2 = 6                     |
+---------------------------+
|i3 : S = schurRing(s);     |
+---------------------------+
|i4 : numgens S             |
|                           |
|o4 = infinity              |
|                           |
|o4 : InfiniteNumber        |
+---------------------------+

Ways to use this method:
========================

  * numgens(SchurRing) -- Number of generators
    of Schur ring.

partitions(Set,BasicList) -- Partitions of a set
************************************************

Synopsis
========

  * Function: partitions (Macaulay2Doc),
  * Usage:
        par = partitions(S,L)
  * Inputs:
      * S, a set (Macaulay2Doc),
      * L, a basic list (Macaulay2Doc), a nonincreasing list
        of integers, or a partition
  * Outputs:
      * par, a list (Macaulay2Doc),

Description
===========

Given a set S and a partition L=\{l_1\geq l_2\cdots\}, the method returns the
list of partitions of the set S of type L, i.e. representations of S as
S=S_1\cup S_2\cup\cdots, where the S_i's are disjoint subsets of S having t_i
elements.

+-----------------------------------------------------------------------------+
|i1 : partitions(set{1,2,3,4},{2,1,1})                                        |
|                                                                             |
|o1 = {set {set {3}, set {4}, set {1, 2}}, set {set {1, 3}, set {4}, set {2}},|
|     ------------------------------------------------------------------------|
|     set {set {3}, set {2}, set {4, 1}}, set {set {1}, set {4}, set {2, 3}}, |
|     ------------------------------------------------------------------------|
|     set {set {4, 2}, set {3}, set {1}}, set {set {1}, set {2}, set {4, 3}}} |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+
|i2 : partitions(set{a,b,c,d,e},new Partition from {3,2})                     |
|                                                                             |
|o2 = {set {set {c, d, e}, set {a, b}}, set {set {c, d, a}, set {e, b}}, set  |
|     ------------------------------------------------------------------------|
|     {set {a, e}, set {c, d, b}}, set {set {c, a, e}, set {d, b}}, set {set  |
|     ------------------------------------------------------------------------|
|     {c, e, b}, set {d, a}}, set {set {c, a, b}, set {d, e}}, set {set {d, a,|
|     ------------------------------------------------------------------------|
|     e}, set {c, b}}, set {set {c, a}, set {d, e, b}}, set {set {c, e}, set  |
|     ------------------------------------------------------------------------|
|     {d, a, b}}, set {set {a, e, b}, set {c, d}}}                            |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * partitions(Set,BasicList), --
    Partitions of a set

plethysm -- Plethystic operations on representations
****************************************************

Synopsis
========

  * Usage:
        pl = plethysm(f,g)
        pl = f @ g
  * Inputs:
      * f, a ring element (Macaulay2Doc), element of
        Symmetric ring or Schur ring
      * g, a ring element (Macaulay2Doc), element of
        Symmetric ring or Schur ring
  * Outputs:
      * pl, a ring element (Macaulay2Doc), element of the
        ring of g

Description
===========

Given a symmetric functions f and the character g of a virtual representation
of a product of general linear and symmetric groups, the method computes the
character of the plethystic composition of f and g. The result of this
operation will be an element of the ring of g. We use the binary operator
@ (Macaulay2Doc), as a synonym for the plethysm function.

+----------------------------------------------------------------------------+
|i1 : R = symmetricRing(QQ,5);                                               |
+----------------------------------------------------------------------------+
|i2 : pl = plethysm(h_2,h_3)                                                 |
|                                                                            |
|      6     4       2 2     3     3                2     2                  |
|o2 = e  - 5e e  + 7e e  - 2e  + 3e e  - 6e e e  + e  - 2e e  + 3e e  + e e  |
|      1     1 2     1 2     2     1 3     1 2 3    3     1 4     2 4    1 5 |
|                                                                            |
|o2 : R                                                                      |
+----------------------------------------------------------------------------+
|i3 : toS pl                                                                 |
|                                                                            |
|o3 = s  + s                                                                 |
|      6    4,2                                                              |
|                                                                            |
|o3 : schurRing (QQ, s, 5)                                                   |
+----------------------------------------------------------------------------+
|i4 : S = schurRing(QQ,q,3);                                                 |
+----------------------------------------------------------------------------+
|i5 : h_2 @ q_{2,1}                                                          |
|                                                                            |
|o5 = q    + q      + q                                                      |
|      4,2    3,2,1    2,2,2                                                 |
|                                                                            |
|o5 : S                                                                      |
+----------------------------------------------------------------------------+
|i6 : plethysm(q_{2,1},q_{2,1})                                              |
|                                                                            |
|o6 = q      + q    + 2q      + q      + q      + 3q                         |
|      6,2,1    5,4     5,3,1    5,2,2    4,4,1     4,3,2                    |
|                                                                            |
|o6 : S                                                                      |
+----------------------------------------------------------------------------+
|i7 : T = schurRing(S,t,2,GroupActing => "Sn");                              |
+----------------------------------------------------------------------------+
|i8 : plethysm(q_{1,1,1}-q_{2,1}+q_{3},q_{2,1}*t_2-t_{1,1})                  |
|                                                                            |
|o8 = (q    - q      - q    + q      + q      - q      + 2q     )t  - q  t   |
|       6,3    6,2,1    5,4    5,2,2    4,4,1    4,3,2     3,3,3  2    () 1,1|
|                                                                            |
|o8 : T                                                                      |
+----------------------------------------------------------------------------+
|i9 : p_3 @ (q_{2,1}*t_2-t_{1,1})                                            |
|                                                                            |
|o9 = (q    - q      - q    + q      + q      - q      + 2q     )t  - q  t   |
|       6,3    6,2,1    5,4    5,2,2    4,4,1    4,3,2     3,3,3  2    () 1,1|
|                                                                            |
|o9 : T                                                                      |
+----------------------------------------------------------------------------+

Ways to use plethysm:
=====================

  * "plethysm(RingElement,RingElement)"
  * 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

For the programmer
==================

The object plethysm, is a method function (Macaulay2Doc).

plethysm(BasicList,RingElement) -- Plethystic operations on representations
***************************************************************************

Synopsis
========

  * Function: plethysm,
  * Usage:
        pl = plethysm(lambda,g)
  * Inputs:
      * lambda, a basic list (Macaulay2Doc), nonincreasing
        sequence of positive integers, or partition
      * g, a ring element (Macaulay2Doc), element of
        Symmetric ring or Schur ring
  * Outputs:
      * pl, a ring element (Macaulay2Doc), element of the
        ring of g

Description
===========

The method computes the character of the representation obtained by applying
the Schur functor S_{\lambda} to the representation with character g, where
\lambda is a partition.

+----------------------------------------------------------+
|i1 : R = symmetricRing(QQ,3);                             |
+----------------------------------------------------------+
|i2 : S = schurRing(QQ,q,3);                               |
+----------------------------------------------------------+
|i3 : toE plethysm({2,1},e_1*e_2-e_3)                      |
|                                                          |
|        4    4         2 2      3      3 2         2     3|
|o3 = e e  + e e e  - 4e e e  - e e  - e e  + 7e e e  - 3e |
|      1 2    1 2 3     1 2 3    2 3    1 3     1 2 3     3|
|                                                          |
|o3 : R                                                    |
+----------------------------------------------------------+
|i4 : plethysm({2,1,1},q_{1,1})                            |
|                                                          |
|o4 = q                                                    |
|      3,3,2                                               |
|                                                          |
|o4 : S                                                    |
+----------------------------------------------------------+
|i5 : T = schurRing(S,t,4,GroupActing => "Sn");            |
+----------------------------------------------------------+
|i6 : plethysm({1,1},q_1*t_{3,1})                          |
|                                                          |
|o6 = q   t  + q   t    + q   t    + q t                   |
|      1,1 4    1,1 3,1    1,1 2,2    2 2,1,1              |
|                                                          |
|o6 : T                                                    |
+----------------------------------------------------------+

Ways to use this method:
========================

  * plethysm(BasicList,RingElement)
    -- Plethystic operations on
    representations

plethysm(RingElement,ClassFunction) -- Plethystic operations on class functions
*******************************************************************************

Synopsis
========

  * Function: plethysm,
  * Usage:
        pl = plethysm(f,cF)
        pl = plethysm(lambda,cF)
  * Inputs:
      * a ring element (Macaulay2Doc),
      * a Class function,

Description
===========

These methods describe the result of applying plethystic operations to a
virtual character of a symmetric group. These operations are described either
via a symmetric function f, or a partition lambda. Since cF corresponds to an
S_n- representation, the option GroupActing, is irrelevant
in this case.

+---------------------------------------------------------+
|i1 : cF = new ClassFunction from {{2} => 1, {1,1} => -1};|
+---------------------------------------------------------+
|i2 : pl1 = plethysm({1,1},cF)                            |
|                                                         |
|o2 = ClassFunction{{1, 1} => 1}                          |
|                   {2} => 1                              |
|                                                         |
|o2 : ClassFunction                                       |
+---------------------------------------------------------+
|i3 : R = symmetricRing 5;                                |
+---------------------------------------------------------+
|i4 : pl2 = plethysm(e_1+e_2,cF)                          |
|                                                         |
|o4 = ClassFunction{{1, 1} => 0}                          |
|                   {2} => 2                              |
|                                                         |
|o4 : ClassFunction                                       |
+---------------------------------------------------------+
|i5 : S = schurRing R;                                    |
+---------------------------------------------------------+
|i6 : symmetricFunction(cF,S)                             |
|                                                         |
|o6 = -s                                                  |
|       1,1                                               |
|                                                         |
|o6 : S                                                   |
+---------------------------------------------------------+
|i7 : symmetricFunction(pl1,S)                            |
|                                                         |
|o7 = s                                                   |
|      2                                                  |
|                                                         |
|o7 : S                                                   |
+---------------------------------------------------------+
|i8 : symmetricFunction(pl2,S)                            |
|                                                         |
|o8 = s  - s                                              |
|      2    1,1                                           |
|                                                         |
|o8 : S                                                   |
+---------------------------------------------------------+

Ways to use this method:
========================

  * "plethysm(BasicList,ClassFunction)"
  * plethysm(RingElement,ClassFunction)
    -- Plethystic operations on
    class functions

pVariable -- Power-sum symmetric functions in a Symmetric ring
**************************************************************

Description
===========

For a Symmetric ring R of dimension n, R.pVariable is a function which assigns
to each index 1\leq i\leq n the i-th power-sum symmetric function. If i is
outside the given bounds, an error is returned.

+-----------------------------+
|i1 : R = symmetricRing(QQ,4);|
+-----------------------------+
|i2 : R.pVariable 2           |
|                             |
|o2 = p                       |
|      2                      |
|                             |
|o2 : R                       |
+-----------------------------+

See also
========

  * eVariable -- Elementary symmetric functions in a
    Symmetric ring
  * hVariable -- Complete symmetric functions in a Symmetric
    ring

For the programmer
==================

The object pVariable, is a symbol (Macaulay2Doc).

scalarProduct -- Standard pairing on symmetric functions/class functions
************************************************************************

Description
===========

This method computes the standard scalar product on the ring \Lambda of
symmetric functions. One way to define this product is by imposing that the
collection of Schur functions s_{\lambda} form an orthonormal basis.

Alternatively, by the correspondence between symmetric functions and virtual
characters of symmetric groups, this scalar product coincides with the standard
scalar product on class functions.

The number of standard tableaux of shape \{4,3,2,1\} is:

+--------------------------------------+
|i1 : R = symmetricRing(QQ,10);        |
+--------------------------------------+
|i2 : S = schurRing(QQ,s,10);          |
+--------------------------------------+
|i3 : scalarProduct(h_1^10,s_{4,3,2,1})|
|                                      |
|o3 = 768                              |
|                                      |
|o3 : QQ                               |
+--------------------------------------+

See also
========

  * internalProduct -- Internal product of symmetric
    functions/class functions

Ways to use scalarProduct:
==========================

  * scalarProduct(ClassFunction,ClassFunction)
    -- Standard scalar
    product of class functions
  * scalarProduct(RingElement,RingElement)
    -- Standard scalar product of
    symmetric functions

For the programmer
==================

The object scalarProduct, is a method function (Macaulay2Doc).

scalarProduct(ClassFunction,ClassFunction) -- Standard scalar product of class functions
****************************************************************************************

Synopsis
========

  * Function: scalarProduct,
  * Usage:
        sp = scalarProduct(ch1,ch2)
  * Inputs:
      * ch1, a Class function,
      * ch2, a Class function,
  * Outputs:
      * sp, a rational number (Macaulay2Doc),

Description
===========

Given virtual characters ch1 and ch2, the method computes the standard pairing
between ch1 and ch2.

+-----------------------------------------------------------------------------+
|i1 : ch1 = new ClassFunction from {{3,2} => 2, {2,2,1} => -2, {3,1,1} => 2,  |
|-----------------------------------------------------------------------------|
|{5} => 1};                                                                   |
+-----------------------------------------------------------------------------+
|i2 : ch2 = new ClassFunction from {{2,2,1} => -2, {5} => 1, {1,1,1,1,1} => 5,|
|-----------------------------------------------------------------------------|
|{3,2} => 3, {4,1} => -2};                                                    |
+-----------------------------------------------------------------------------+
|i3 : scalarProduct(ch1,ch2)                                                  |
|                                                                             |
|     17                                                                      |
|o3 = --                                                                      |
|     10                                                                      |
|                                                                             |
|o3 : QQ                                                                      |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * scalarProduct(ClassFunction,ClassFunction)
    -- Standard scalar
    product of class functions

scalarProduct(RingElement,RingElement) -- Standard scalar product of symmetric functions
****************************************************************************************

Synopsis
========

  * Function: scalarProduct,
  * Usage:
        sp = scalarProduct(f1,f2)
  * Inputs:
      * f1, a ring element (Macaulay2Doc), element of a
        Symmetric Ring
      * f2, a ring element (Macaulay2Doc), element of a
        Symmetric Ring
  * Outputs:
      * sp, a rational number (Macaulay2Doc),

Description
===========

Given symmetric functions f1 and f2, the method computes the standard pairing
between f1 and f2.

+-------------------------------+
|i1 : R = symmetricRing(QQ,5);  |
+-------------------------------+
|i2 : S = schurRing R           |
|                               |
|o2 = S                         |
|                               |
|o2 : SchurRing                 |
+-------------------------------+
|i3 : scalarProduct(h_5,p_5)    |
|                               |
|o3 = 1                         |
|                               |
|o3 : QQ                        |
+-------------------------------+
|i4 : scalarProduct(S_{4,1},p_5)|
|                               |
|o4 = -1                        |
|                               |
|o4 : QQ                        |
+-------------------------------+

Indeed, the coefficients of s_5 and s_{4,1} in the s-basis expansion of h_5 are
as computed above:

+-----------------------------------------------+
|i5 : R = symmetricRing(QQ,5);                  |
+-----------------------------------------------+
|i6 : toS p_5                                   |
|                                               |
|o6 = s  - s    + s      - s        + s         |
|      5    4,1    3,1,1    2,1,1,1    1,1,1,1,1|
|                                               |
|o6 : schurRing (QQ, s, 5)                      |
+-----------------------------------------------+

Ways to use this method:
========================

  * scalarProduct(RingElement,RingElement)
    -- Standard scalar product of
    symmetric functions

schurLevel -- Number of SchurRings the ring is a tensor product of.
*******************************************************************

Synopsis
========

  * Usage:
        lev = schurLevel(R)
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * lev, an integer (Macaulay2Doc),

Description
===========

For the representation ring R of a product of lev general linear groups, the
function returns lev. If R is not a representation ring, then the function
returns 0.

+---------------------------+
|i1 : R = schurRing(QQ,r,3);|
+---------------------------+
|i2 : S = schurRing(R,s,5); |
+---------------------------+
|i3 : T = schurRing(S,t,2); |
+---------------------------+
|i4 : schurLevel R          |
|                           |
|o4 = 1                     |
+---------------------------+
|i5 : schurLevel S          |
|                           |
|o5 = 2                     |
+---------------------------+
|i6 : schurLevel T          |
|                           |
|o6 = 3                     |
+---------------------------+
|i7 : schurLevel QQ         |
|                           |
|o7 = 0                     |
+---------------------------+

Ways to use schurLevel:
=======================

  * "schurLevel(Ring)"

For the programmer
==================

The object schurLevel, is a method function (Macaulay2Doc).

schurResolution -- Compute an ``approximate'' equivariant resolution of a module.
*********************************************************************************

Synopsis
========

  * Usage:
        resol = schurResolution(rep,M,lS)
        resol = schurResolution(rep,M)
  * Inputs:
      * rep, a ring element (Macaulay2Doc), element of a
        SchurRing
      * M, a list (Macaulay2Doc), list of representations,
        corresponding to the homogeneous components of a module M.
      * lS, a list (Macaulay2Doc), list of representations,
        corresponding to the homogeneous components of a polynomial ring S.
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit,
        => ..., default value 0, Specifies the maximal degree of syzygies
        to be computed
      * SyzygyLimit,
        => ..., default value 0, Specifies the number of syzygy modules to
        be computed
  * Outputs:
      * resol, a list (Macaulay2Doc),

Description
===========

Given a representation rep of a (product of) general linear or symmetric
group(s) G, we consider the symmetric algebra S = Sym(rep) and an S-module M
which is also a G-module in such a way that the S-module structure on M
respects the G-action. More generally, S can be any graded ring, of which one
inputs only finitely many homogeneous components as a list lS of characters of
G. The main reason why we allow this generality is because most of the time it
is computationally expensive to calculate the symmetric powers of the
representation rep, so we give the user the option to compute these symmetric
powers by different methods and use the results as input for the
schurResolution routine.

We are interested in computing an equivariant resolution of M. This depends on
both the G- and S-module structure of M in general, but in many examples that
occur in practice, it turns out that the differentials in the resolution have
maximal rank among all G-module homomorphisms between the free modules in the
resolution. We will therefore assume that this is the case for the module M
that we are trying to resolve, and thus disregard its S-module structure.

More precisely, the assumptions that we make about M are as follows: M is a
graded S-module, with M_i = 0 for i<0, where the grading on S is standard,
given by setting the degrees of the elements of rep equal to 1. Since we
assumed that the G-structure of M determines the syzygies, all the relevant
information is concentrated in finitely many homogeneous components of M
(namely up to reg(M)+pd(M), the sum of the regularity and the projective
dimension of M). We will thus assume that M is given as a list of
G-representations, corresponding to (a subset of) the relevant homogeneous
components. The function schurResolution takes as inputs the representation
rep, the module M, and as optional arguments a DegreeLimit d, and a SyzygyLimit
c. The ring S itself can occur as input data, being described as a list of
G-representations, just like M. The routine outputs the generators of degree at
most d of the first c+1 syzygy modules (from 0 to c). They are listed as a
sequence of pairs, consisting of the degree of the generators of the syzygy
modules together with the characters of the G-representations they correspond
to. If the syzygy bound c is not given, then all syzygy modules are computed.
If the degree bound d is not given, then it is assumed to be equal to the
largest degree among the homogeneous components of M in the input, i.e. one
less than the length of the List (Macaulay2Doc), M.

The example below computes the resolution of the quadratic Veronese surface in
P^5.

+------------------------------------------------------------+
|i1 : S = schurRing(QQ,s,3)                                  |
|                                                            |
|o1 = S                                                      |
|                                                            |
|o1 : SchurRing                                              |
+------------------------------------------------------------+
|i2 : rep = s_{2}                                            |
|                                                            |
|o2 = s                                                      |
|      2                                                     |
|                                                            |
|o2 : S                                                      |
+------------------------------------------------------------+
|i3 : M = {1_S,s_{2},s_{4},s_{6},s_{8},s_{10},s_{12}}        |
|                                                            |
|o3 = {s  , s , s , s , s , s  , s  }                        |
|       ()   2   4   6   8   10   12                         |
|                                                            |
|o3 : List                                                   |
+------------------------------------------------------------+
|i4 : schurResolution(rep,M)                                 |
|                                                            |
|o4 = {{(0, s  )}, {(2, s   )}, {(3, s     )}, {(4, s     )}}|
|            ()          2,2          3,2,1          3,3,2   |
|                                                            |
|o4 : List                                                   |
+------------------------------------------------------------+

Next, we compute the syzygies of degree at most 7 in the resolution of the
cubic Veronese embedding of P^2.

+-----------------------------------------------------------------------------+
|i5 : rep = s_{3}                                                             |
|                                                                             |
|o5 = s                                                                       |
|      3                                                                      |
|                                                                             |
|o5 : S                                                                       |
+-----------------------------------------------------------------------------+
|i6 : M = {1_S,s_{3},s_{6},s_{9},s_{12},s_{15},s_{18},s_{21},s_{24},s_{27}}   |
|                                                                             |
|o6 = {s  , s , s , s , s  , s  , s  , s  , s  , s  }                         |
|       ()   3   6   9   12   15   18   21   24   27                          |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : d = 7                                                                   |
|                                                                             |
|o7 = 7                                                                       |
+-----------------------------------------------------------------------------+
|i8 : schurResolution(rep,M,DegreeLimit => d)                                 |
|                                                                             |
|o8 = {{(0, s  )}, {(2, s   )}, {(3, s      + s    + s      + s     )}, {(4,  |
|            ()          4,2          6,2,1    5,4    5,3,1    4,3,2          |
|     ------------------------------------------------------------------------|
|     s      + s      + s      + s      + s      + s      + s     )}, {(5,    |
|      7,4,1    7,3,2    6,5,1    6,4,2    6,3,3    5,5,2    5,4,3            |
|     ------------------------------------------------------------------------|
|     s      + s      + s      + s      + s      + s      + s     )}, {(6,    |
|      8,5,2    8,4,3    7,6,2    7,5,3    7,4,4    6,6,3    6,5,4            |
|     ------------------------------------------------------------------------|
|     s      + s      + s      + s     )}, {(7, s     )}}                     |
|      9,5,4    8,7,3    8,6,4    7,6,5          9,7,5                        |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+

We can compute the resolution of the ideal of 2\times 2 minors of a 3\times 4
matrix, which corresponds to the Segre embedding of P^2\times P^3:

+-----------------------------------------------------------------------------+
|i9 : T = schurRing(S,t,4)                                                    |
|                                                                             |
|o9 = T                                                                       |
|                                                                             |
|o9 : SchurRing                                                               |
+-----------------------------------------------------------------------------+
|i10 : rep = s_1 * t_1                                                        |
|                                                                             |
|o10 = s t                                                                    |
|       1 1                                                                   |
|                                                                             |
|o10 : T                                                                      |
+-----------------------------------------------------------------------------+
|i11 : M = {1_T} | apply(splice{1..8},i -> s_i * t_i)                         |
|                                                                             |
|o11 = {t  , s t , s t , s t , s t , s t , s t , s t , s t }                  |
|        ()   1 1   2 2   3 3   4 4   5 5   6 6   7 7   8 8                   |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : schurResolution(rep,M)                                                 |
|                                                                             |
|o12 = {{(0, t  )}, {(2, s   t   )}, {(3, s     t    + s   t     )}, {(4,     |
|             ()          1,1 1,1          1,1,1 2,1    2,1 1,1,1             |
|      -----------------------------------------------------------------------|
|      s     t      + s   t       )}, {(5, s     t       ), (6,               |
|       2,1,1 2,1,1    3,1 1,1,1,1          3,1,1 2,1,1,1                     |
|      -----------------------------------------------------------------------|
|      s     t     )}, {(7, s     t       )}, {(8, s     t       )}}          |
|       2,2,2 2,2,2          3,2,2 2,2,2,1          3,3,2 2,2,2,2             |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

The following example computes the equivariant resolution of the residue field
of a polynomial ring in n=5 variables, with respect to the action of the
symmetric group S_n.

+-----------------------------------------------------------------------------+
|i13 : n = 5;                                                                 |
+-----------------------------------------------------------------------------+
|i14 : S = schurRing(QQ,s,n,GroupActing => "Sn");                             |
+-----------------------------------------------------------------------------+
|i15 : rep = s_n + s_{n-1,1};                                                 |
+-----------------------------------------------------------------------------+
|i16 : M = {s_n}                                                              |
|                                                                             |
|o16 = {s }                                                                   |
|        5                                                                    |
|                                                                             |
|o16 : List                                                                   |
+-----------------------------------------------------------------------------+
|i17 : schurResolution(rep,M,DegreeLimit => n)                                |
|                                                                             |
|o17 = {{(0, s )}, {(1, s  + s   )}, {(2, s    + s     )}, {(3, s      +      |
|             5          5    4,1          4,1    3,1,1          3,1,1        |
|      -----------------------------------------------------------------------|
|      s       )}, {(4, s        + s         )}, {(5, s         )}}           |
|       2,1,1,1          2,1,1,1    1,1,1,1,1          1,1,1,1,1              |
|                                                                             |
|o17 : List                                                                   |
+-----------------------------------------------------------------------------+

Generalizing this, we can compute the equivariant resolution of the quotient of
the polynomial ring in n=5 variables by the ideal of square-free monomials of
degree two, with respect to the action of the symmetric group S_n.

+-----------------------------------------------------------------------------+
|i18 : M = {s_n} | splice{n:rep};                                             |
+-----------------------------------------------------------------------------+
|i19 : schurResolution(rep,M)                                                 |
|                                                                             |
|o19 = {{(0, s )}, {(2, s  + s    + s   )}, {(3, s    + s    + s      +       |
|             5          5    4,1    3,2          4,1    3,2    3,1,1         |
|      -----------------------------------------------------------------------|
|      s     )}, {(4, s      + s      + s       )}, {(5, s       )}}          |
|       2,2,1          3,1,1    2,2,1    2,1,1,1          2,1,1,1             |
|                                                                             |
|o19 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use schurResolution:
============================

  * "schurResolution(RingElement,List)"
  * "schurResolution(RingElement,List,List)"

For the programmer
==================

The object schurResolution, is a method function with options (Macaulay2Doc).

schurResolution(...,DegreeLimit=>...) -- Specifies the maximal degree of syzygies to be computed
************************************************************************************************

Description
===========

This is an optional argument for the schurResolution,
routine. It specifies an upper bound for the degrees of the generators of the
syzygy modules in the equivariant resolution of an equivariant module M to be
computed by the routine. If a DegreeLimit is not specified, then it is assumed
to be equal to the maximal degree in which the module M is specified as a
representation.

+-----------------------------------------------------------------------------+
|i1 : A = schurRing(a,3,GroupActing => "Sn");                                 |
+-----------------------------------------------------------------------------+
|i2 : B = schurRing(A,b,2);                                                   |
+-----------------------------------------------------------------------------+
|i3 : rep = (a_3 + a_{2,1}) * b_1                                             |
|                                                                             |
|o3 = (a  + a   )b                                                            |
|       3    2,1  1                                                           |
|                                                                             |
|o3 : B                                                                       |
+-----------------------------------------------------------------------------+
|i4 : d = dim rep                                                             |
|                                                                             |
|o4 = 6                                                                       |
+-----------------------------------------------------------------------------+
|i5 : M = {a_3 * 1_B};                                                        |
+-----------------------------------------------------------------------------+
|i6 : sR = schurResolution(rep,M,DegreeLimit => d)                            |
|                                                                             |
|o6 = {{(0, a b  )}, {(1, (a  + a   )b )}, {(2, (a    + a     )b  + (2a  +    |
|            3 ()           3    2,1  1           2,1    1,1,1  2      3      |
|     ------------------------------------------------------------------------|
|     2a   )b   )}, {(3, a     b  + (a  + 3a    + a     )b   )}, {(4, (a    + |
|       2,1  1,1          1,1,1 3     3     2,1    1,1,1  2,1           2,1   |
|     ------------------------------------------------------------------------|
|     a     )b    + (2a  + 2a   )b   )}, {(5, (a  + a   )b   )}, {(6,         |
|      1,1,1  3,1      3     2,1  2,2           3    2,1  3,2                 |
|     ------------------------------------------------------------------------|
|     a b   )}}                                                               |
|      3 3,3                                                                  |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

Further information
===================

  * Default value: 0
  * Function: schurResolution, -- Compute an
    ``approximate'' equivariant resolution of a module.
  * Option key: DegreeLimit (Macaulay2Doc), -- an optional
    argument

See also
========

  * schurResolution(...,SyzygyLimit=>...)
    -- Specifies the
    number of syzygy modules to be computed

Functions with optional argument named DegreeLimit:
===================================================

  * adjoint(...,DegreeLimit=>...) (missing documentation)
  * "compose(Module,Module,Module,DegreeLimit=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * dual(ChainComplex,DegreeLimit=>...) (missing documentation)
  * dual(Matrix,DegreeLimit=>...) (missing documentation)
  * dual(SheafMap,DegreeLimit=>...) (missing documentation)
  * "End(...,DegreeLimit=>...)" -- see End (Macaulay2Doc), -- module
    of endomorphisms
  * "gb(...,DegreeLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "Hom(...,DegreeLimit=>...)" -- see Hom (Macaulay2Doc), -- module
    of homomorphisms
  * "homomorphism'(...,DegreeLimit=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "intersectInP(...,DegreeLimit=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "minimalBetti(...,DegreeLimit=>...)" -- see minimalBetti (Macaulay2Doc),
    -- minimal betti numbers of (the minimal free
    resolution of) a homogeneous ideal or module
  * "pushForward(...,DegreeLimit=>...)" -- see
    pushForward(RingMap,Module) (Macaulay2Doc),
  * quotient(...,DegreeLimit=>...) (Saturation)
  * "saturate(...,DegreeLimit=>...)" -- see
    quotient(...,DegreeLimit=>...) (Saturation),
  * "analyticSpread(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "associatedGradedRing(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "distinguished(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "isLinearType(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "isReduction(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "minimalReduction(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "multiplicity(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "normalCone(Ideal,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "normalCone(Ideal,RingElement,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "reesAlgebra(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * reesIdeal(...,DegreeLimit=>...) (ReesAlgebra)
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "specialFiber(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "specialFiberIdeal(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * resolution(...,DegreeLimit=>...) (Macaulay2Doc),
    --
    compute only up to this degree
  * schurResolution(...,DegreeLimit=>...)
    -- Specifies the
    maximal degree of syzygies to be computed
  * sheafHom(...,DegreeLimit=>...) (missing documentation)
  * "syz(...,DegreeLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

schurResolution(...,SyzygyLimit=>...) -- Specifies the number of syzygy modules to be computed
**********************************************************************************************

Description
===========

This is an optional argument for the schurResolution,
routine. It specifies an upper bound for the number of syzygy modules in the
equivariant resolution of an equivariant module M to be computed by the
routine. If a SyzygyLimit is not specified, then all syzygy modules are
computed.

The example below computes the 0-th to 3-rd syzygy modules of the 5-th Veronese
embedding of P^2.

+-----------------------------------------------------------------------------+
|i1 : S = schurRing(s,3);                                                     |
+-----------------------------------------------------------------------------+
|i2 : rep = s_{5};                                                            |
+-----------------------------------------------------------------------------+
|i3 : M = {1_S,s_{5},s_{10},s_{15},s_{20},s_{25},s_{30}};                     |
+-----------------------------------------------------------------------------+
|i4 : schurResolution(rep,M,SyzygyLimit => 3)                                 |
|                                                                             |
|o4 = {{(0, s  )}, {(2, s    + s   )}, {(3, s       + s     + s       + s     |
|            ()          8,2    6,4          12,2,1    11,4    11,3,1    10,5 |
|     ------------------------------------------------------------------------|
|     + s       + s       + s    + 2s      + s      + s    + s      + s      +|
|        10,4,1    10,3,2    9,6     9,5,1    9,4,2    8,7    8,6,1    8,5,2  |
|     ------------------------------------------------------------------------|
|     s      + s      + s      + s     )}, {(4, s       + s       + 2s       +|
|      8,4,3    7,6,2    7,5,3    6,5,4          15,4,1    15,3,2     14,5,1  |
|     ------------------------------------------------------------------------|
|     s       + s       + s     + 3s       + 3s       + 2s       + s     +    |
|      14,4,2    14,3,3    13,7     13,6,1     13,5,2     13,4,3    12,8      |
|     ------------------------------------------------------------------------|
|     3s       + 4s       + 4s       + s       + s     + 3s       + 5s       +|
|       12,7,1     12,6,2     12,5,3    12,4,4    11,9     11,8,1     11,7,2  |
|     ------------------------------------------------------------------------|
|     5s       + 3s       + 2s       + 3s       + 5s       + 4s       +       |
|       11,6,3     11,5,4     10,9,1     10,8,2     10,7,3     10,6,4         |
|     ------------------------------------------------------------------------|
|     3s       + 2s      + 3s      + 4s      + 3s      + s      + 2s      +   |
|       10,5,5     9,9,2     9,8,3     9,7,4     9,6,5    8,8,4     8,7,5     |
|     ------------------------------------------------------------------------|
|     s     )}}                                                               |
|      7,7,6                                                                  |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Further information
===================

  * Default value: 0
  * Function: schurResolution, -- Compute an
    ``approximate'' equivariant resolution of a module.
  * Option key: SyzygyLimit (Macaulay2Doc), -- an optional
    argument

See also
========

  * schurResolution(...,DegreeLimit=>...)
    -- Specifies the
    maximal degree of syzygies to be computed

Functions with optional argument named SyzygyLimit:
===================================================

  * "gb(...,SyzygyLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * resolution(...,SyzygyLimit=>...) (Macaulay2Doc)
    -- stop
    when this number of syzygies is reached
  * schurResolution(...,SyzygyLimit=>...)
    -- Specifies the
    number of syzygy modules to be computed
  * "syz(...,SyzygyLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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 (Macaulay2Doc), instead of
a List (Macaulay2Doc), 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 (Macaulay2Doc).

+------------------+
|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 (Macaulay2Doc),:

+-------------------------------------------------------+
|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                                             |
+-------------------------------------------------------+

See also
========

  * schurRing -- Make a SchurRing

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:
==============================

  * coefficientRing(SchurRing), --
    Coefficient ring of a Schur ring
  * numgens(SchurRing) -- Number of generators
    of Schur ring.
  * "SchurRing _ List"
  * "SchurRing _ Sequence"
  * "SchurRing _ ZZ"
  * "toS(RingElement,SchurRing)" -- see toS, -- Schur (s-) basis
    representation

For the programmer
==================

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

schurRing -- Make a SchurRing
*****************************

Description
===========

S = schurRing(A,s,n) creates a Schur ring of degree n over the base ring A,
with variables based on the symbol s. This is the representation ring for the
general linear group of n by n matrices, tensored with the ring A. If s is
already assigned a value as a variable in a ring, its base symbol will be used,
if it is possible to determine.

+-----------------------------------------------------------------------------+
|i1 : S = schurRing(QQ[x],s,3);                                               |
+-----------------------------------------------------------------------------+
|i2 : (x*s_{2,1}+s_3)^2                                                       |
|                                                                             |
|                           2                   2                 2           |
|o2 = s  + (2x + 1)s    + (x  + 2x + 1)s    + (x  + 2x)s      + (x  + 1)s    +|
|      6            5,1                 4,2             4,1,1            3,3  |
|     ------------------------------------------------------------------------|
|        2                2                                                   |
|     (2x  + 2x)s      + x s                                                  |
|                3,2,1      2,2,2                                             |
|                                                                             |
|o2 : S                                                                       |
+-----------------------------------------------------------------------------+

Alternatively, the elements of a Schur ring may be interpreted as characters of
symmetric groups. To indicate this interpretation, one has to set the value of
the option GroupActing, to "Sn".

+--------------------------------------------+
|i3 : S = schurRing(s,4,GroupActing => "Sn");|
+--------------------------------------------+
|i4 : exteriorPower(2,s_(3,1))               |
|                                            |
|o4 = s                                      |
|      2,1,1                                 |
|                                            |
|o4 : S                                      |
+--------------------------------------------+

If the dimension n is not specified, then one should think of S as the full
ring of symmetric functions over the base A, i.e. there is no restriction on
the number of parts of the partitions indexing the generators of S.

+--------------------------------------------------------------+
|i5 : S = schurRing(ZZ/5,t)                                    |
|                                                              |
|o5 = S                                                        |
|                                                              |
|o5 : SchurRing                                                |
+--------------------------------------------------------------+
|i6 : (t_(2,1)-t_3)^2                                          |
|                                                              |
|o6 = t  - t    - t      + 2t    + t        + t      + t       |
|      6    5,1    4,1,1     3,3    3,1,1,1    2,2,2    2,2,1,1|
|                                                              |
|o6 : S                                                        |
+--------------------------------------------------------------+

If the base ring A is not specified, then QQ (Macaulay2Doc), is used
instead.

+--------------------------------------------------+
|i7 : S = schurRing(r,2,EHPVariables => (re,rh,rp))|
|                                                  |
|o7 = S                                            |
|                                                  |
|o7 : SchurRing                                    |
+--------------------------------------------------+
|i8 : toH r_(2,1)                                  |
|                                                  |
|       3                                          |
|o8 = rh  - rh rh                                  |
|       1     1  2                                 |
|                                                  |
|o8 : QQ[re ..re , rp ..rp , rh ..rh ]             |
|          1    2    1    2    1    2              |
+--------------------------------------------------+

See also
========

  * SchurRing -- The class of all Schur rings
  * symmetricRing -- Make a Symmetric ring

Ways to use schurRing:
======================

  * "schurRing(Ring,Symbol)"
  * "schurRing(Ring,Symbol,ZZ)"
  * "schurRing(Ring,Thing)"
  * "schurRing(Ring,Thing,ZZ)"
  * "schurRing(Thing)"
  * "schurRing(Thing,ZZ)"
  * schurRing(Ring) -- The Schur ring corresponding
    to a given Symmetric ring.

For the programmer
==================

The object schurRing, is a method function with options (Macaulay2Doc).

schurRing(Ring) -- The Schur ring corresponding to a given Symmetric ring.
**************************************************************************

Synopsis
========

  * Function: schurRing,
  * Usage:
        S = schurRing R
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * EHPVariables, => ..., default value (e,h,p),
        Specifies sequence of symbols representing e-, h-, and p-functions
      * GroupActing, => ..., default value "GL", Specifies
        the group that is acting
      * SVariable, => ..., default value s, Specifies symbol
        representing s-functions
  * Outputs:
      * S, a Schur ring,

Description
===========

Given a ring R, the function schurRing attempts to return a Schur ring S that
is associated to R in a natural way. Namely, if the attribute R.Schur points to
a Schur ring, then the function returns that ring. If R is already a Schur
ring, then the ring R is returned. Otherwise, if the Schur level of R is at
least one, then the function constructs a Schur ring over the base ring A of R,
having the same relative dimension over A as R. If the Schur level of R is
zero, then an error is returned.

+-----------------------------+
|i1 : R = schurRing(QQ,r,6);  |
+-----------------------------+
|i2 : schurRing R             |
|                             |
|o2 = R                       |
|                             |
|o2 : SchurRing               |
+-----------------------------+
|i3 : Q = symmetricRing(QQ,3);|
+-----------------------------+
|i4 : A = schurRing Q;        |
+-----------------------------+
|i5 : schurRing Q             |
|                             |
|o5 = A                       |
|                             |
|o5 : SchurRing               |
+-----------------------------+

See also
========

  * symmetricRing -- Make a Symmetric ring

Ways to use this method:
========================

  * schurRing(Ring) -- The Schur ring corresponding
    to a given Symmetric ring.

SchurRingElement -- A type describing elements of a SchurRing
*************************************************************

Description
===========

+---------------------------------------------+
|i1 : S = schurRing(s,5)                      |
|                                             |
|o1 = S                                       |
|                                             |
|o1 : SchurRing                               |
+---------------------------------------------+
|i2 : a = s_{3,2,1}                           |
|                                             |
|o2 = s                                       |
|      3,2,1                                  |
|                                             |
|o2 : S                                       |
+---------------------------------------------+
|i3 : instance(a,SchurRingElement)            |
|                                             |
|o3 = true                                    |
+---------------------------------------------+
|i4 : T = schurRing(S,t,3,GroupActing => "Sn")|
|                                             |
|o4 = T                                       |
|                                             |
|o4 : SchurRing                               |
+---------------------------------------------+
|i5 : b = t_{2,1}+t_3                         |
|                                             |
|o5 = t  + t                                  |
|      3    2,1                               |
|                                             |
|o5 : T                                       |
+---------------------------------------------+
|i6 : instance(a*b,SchurRingElement)          |
|                                             |
|o6 = true                                    |
+---------------------------------------------+

Methods that use an object of class SchurRingElement:
=====================================================

  * 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

For the programmer
==================

The object SchurRingElement, is a type (Macaulay2Doc),
with ancestor classes RingElement (Macaulay2Doc),
< BasicList (Macaulay2Doc) <
Thing (Macaulay2Doc).

SchurRingIndexedVariableTable
*****************************

Description
===========

This class is used as part of the implementation of a type of indexed variable
used just for Schur rings.

See also
========

  * IndexedVariableTable (Macaulay2Doc)

Methods that use an object of class SchurRingIndexedVariableTable:
==================================================================

  * "SchurRingIndexedVariableTable _ Thing"

For the programmer
==================

The object SchurRingIndexedVariableTable,
is a type (Macaulay2Doc), with ancestor classes
IndexedVariableTable (Macaulay2Doc), <
MutableHashTable (Macaulay2Doc) < HashTable (Macaulay2Doc)
< Thing (Macaulay2Doc).

SVariable -- Specifies symbol representing s-functions
******************************************************

Description
===========

This is an optional argument for the constructor of a Symmetric ring. It
indicates the symbol to be used to denote s-functions in the associated Schur
ring. The default value is s.

+-------------------------------------------------------+
|i1 : R = symmetricRing(QQ,5,SVariable => getSymbol"s");|
+-------------------------------------------------------+
|i2 : S = schurRing R                                   |
|                                                       |
|o2 = S                                                 |
|                                                       |
|o2 : SchurRing                                         |
+-------------------------------------------------------+
|i3 : s_2^2                                             |
|                                                       |
|o3 = s  + s    + s                                     |
|      4    3,1    2,2                                  |
|                                                       |
|o3 : S                                                 |
+-------------------------------------------------------+

See also
========

  * EHPVariables -- Specifies sequence of symbols
    representing e-, h-, and p-functions

Functions with optional argument named SVariable:
=================================================

  * "schurRing(...,SVariable=>...)"
  * "symmetricRing(...,SVariable=>...)"

For the programmer
==================

The object SVariable, is a symbol (Macaulay2Doc).

symmetricFunction -- Converts class function to symmetric function
******************************************************************

Synopsis
========

  * Usage:
        f = symmetricFunction(ch,S)
  * Inputs:
      * ch, a Class function,
      * S, a ring (Macaulay2Doc), a Symmetric or Schur ring
  * Outputs:
      * f, a ring element (Macaulay2Doc), element of a
        Symmetric or Schur ring

Description
===========

Given a virtual character cF of a symmetric group, and given a Symmetric ring
S, the method computes the corresponding symmetric function as an element of S.

+-------------------------------------------------+
|i1 : S = symmetricRing(QQ,4);                    |
+-------------------------------------------------+
|i2 : cF = new ClassFunction from {{1,1,1,1}=>24};|
+-------------------------------------------------+
|i3 : symmetricFunction(cF,S)                     |
|                                                 |
|      4                                          |
|o3 = p                                           |
|      1                                          |
|                                                 |
|o3 : S                                           |
+-------------------------------------------------+
|i4 : symmetricFunction(cF,schurRing S)           |
|                                                 |
|o4 = s  + 3s    + 2s    + 3s      + s            |
|      4     3,1     2,2     2,1,1    1,1,1,1     |
|                                                 |
|o4 : schurRing (QQ, s, 4)                        |
+-------------------------------------------------+

See also
========

  * classFunction -- Converts symmetric function to class
    function

Ways to use symmetricFunction:
==============================

  * "symmetricFunction(ClassFunction,Ring)"

For the programmer
==================

The object symmetricFunction, is a method function (Macaulay2Doc).

symmetricRing -- Make a Symmetric ring
**************************************

Synopsis
========

  * Usage:
        symmetricRing(A,n)
        symmetricRing n
  * Inputs:
      * A, a ring (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * EHPVariables, => ..., default value (e,h,p),
        Specifies sequence of symbols representing e-, h-, and p-functions
      * GroupActing, => ..., default value "GL", Specifies
        the group that is acting
      * SVariable, => ..., default value s, Specifies symbol
        representing s-functions

Description
===========

The method symmetricRing creates a Symmetric ring of dimension n over a base
ring A. This is the subring of the ring of symmetric functions over the base A
consisting of polynomials in the first n elementary (or complete, or power sum)
symmetric functions. If A is not specified, then it is assumed to be QQ (Macaulay2Doc).

+-------------------------------------------+
|i1 : R = symmetricRing(QQ[x,y,z],4)        |
|                                           |
|o1 = R                                     |
|                                           |
|o1 : PolynomialRing                        |
+-------------------------------------------+
|i2 : e_2*x+y*p_3+h_2                       |
|                                           |
|o2 = y*p  + x*e  + h                       |
|        3      2    2                      |
|                                           |
|o2 : R                                     |
+-------------------------------------------+
|i3 : toS oo                                |
|                                           |
|o3 = y*s  - y*s    + s  + y*s      + x*s   |
|        3      2,1    2      1,1,1      1,1|
|                                           |
|o3 : schurRing (QQ[x..z], s, 4)            |
+-------------------------------------------+

The elements of a Symmetric ring can be interpreted as characters of either
symmetric or general linear groups. This is controlled by the value of the
option GroupActing, whose default value is "GL" (general
linear group). The other possibility for its value is "Sn" (symmetric group).

+------------------------------------------------+
|i4 : R = symmetricRing(QQ,3,GroupActing => "Sn")|
|                                                |
|o4 = R                                          |
|                                                |
|o4 : PolynomialRing                             |
+------------------------------------------------+
|i5 : toE symmetricPower(2,e_2)                  |
|                                                |
|      2                                         |
|o5 = e  - e                                     |
|      1    2                                    |
|                                                |
|o5 : R                                          |
+------------------------------------------------+

See also
========

  * SchurRing -- The class of all Schur rings

Ways to use symmetricRing:
==========================

  * "symmetricRing(Ring,ZZ)"
  * "symmetricRing(ZZ)"
  * symmetricRing(Ring) -- The Symmetric ring
    corresponding to a given (Schur) ring.

For the programmer
==================

The object symmetricRing, is a method function with options (Macaulay2Doc).

symmetricRing(Ring) -- The Symmetric ring corresponding to a given (Schur) ring.
********************************************************************************

Synopsis
========

  * Function: symmetricRing,
  * Usage:
        R = symmetricRing S
  * Inputs:
      * S, a ring (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * EHPVariables, => ..., default value (e,h,p),
        Specifies sequence of symbols representing e-, h-, and p-functions
      * GroupActing, => ..., default value "GL", Specifies
        the group that is acting
      * SVariable, => ..., default value s, Specifies symbol
        representing s-functions
  * Outputs:
      * R, a ring (Macaulay2Doc),

Description
===========

Given a (Schur) ring S, the function symmetricRing returns a (Symmetric) ring R
that is associated to S in a natural way. Namely, if the attribute
S.symmetricRing points to a ring, then the function returns that ring. If S is
not a Schur ring, then the function returns S. Otherwise, if S is a Schur ring,
then the function constructs a polynomial ring over the Symmetric ring R_A of
the base ring A of R, having the same relative dimension over R_A as S over A.

+-------------------------------------------------------+
|i1 : A = schurRing(QQ,a,6);                            |
+-------------------------------------------------------+
|i2 : B = schurRing(A,b,3);                             |
+-------------------------------------------------------+
|i3 : symmetricRing B                                   |
|                                                       |
|o3 = QQ[e ..e , p ..p , h ..h ][e ..e , p ..p , h ..h ]|
|         1   6   1   6   1   6   1   3   1   3   1   3 |
|                                                       |
|o3 : PolynomialRing                                    |
+-------------------------------------------------------+
|i4 : symmetricRing ZZ                                  |
|                                                       |
|o4 = ZZ                                                |
|                                                       |
|o4 : Ring                                              |
+-------------------------------------------------------+

See also
========

  * schurRing -- Make a SchurRing

Ways to use this method:
========================

  * symmetricRing(Ring) -- The Symmetric ring
    corresponding to a given (Schur) ring.

toE -- Elementary symmetric (e-) basis representation
*****************************************************

Synopsis
========

  * Usage:
        fe = toE f
  * Inputs:
      * f, a ring element (Macaulay2Doc), element of a
        Symmetric or Schur ring
  * Outputs:
      * fe, a ring element (Macaulay2Doc), element of a
        Symmetric ring

Description
===========

Given a symmetric function f, the function toE yields a representation of f as
a polynomial in the elementary symmetric functions.

If f is an element of a Schur ring S then the output fe is an element of the
Symmetric ring associated to S (see symmetricRing).

+-------------------------------+
|i1 : R = symmetricRing 7;      |
+-------------------------------+
|i2 : toE(h_3*e_3)              |
|                               |
|      3                2       |
|o2 = e e  - 2e e e  + e        |
|      1 3     1 2 3    3       |
|                               |
|o2 : R                         |
+-------------------------------+
|i3 : S = schurRing(s,4)        |
|                               |
|o3 = S                         |
|                               |
|o3 : SchurRing                 |
+-------------------------------+
|i4 : toE S_{3,2,1}             |
|                               |
|               2    2          |
|o4 = e e e  - e  - e e         |
|      1 2 3    3    1 4        |
|                               |
|o4 : QQ[e ..e , p ..p , h ..h ]|
|         1   4   1   4   1   4 |
+-------------------------------+

This also works over tensor products of Symmetric/Schur rings.

+-----------------------------------------------------------------------------+
|i5 : R = schurRing(r, 4, EHPVariables => (a,b,c));                           |
+-----------------------------------------------------------------------------+
|i6 : S = schurRing(R, s, 2, EHPVariables => (x,y,z));                        |
+-----------------------------------------------------------------------------+
|i7 : T = schurRing(S, t, 3);                                                 |
+-----------------------------------------------------------------------------+
|i8 : A = symmetricRing T;                                                    |
+-----------------------------------------------------------------------------+
|i9 : f = (r_1+s_1+t_1)^2                                                     |
|                                                                             |
|o9 = t  + t    + (2r  s  + 2r s  )t  + (s  + s    + 2r s  + (r  +            |
|      2    1,1      () 1     1 ()  1     2    1,1     1 1     2              |
|     ------------------------------------------------------------------------|
|     r   )s  )t                                                              |
|      1,1  ()  ()                                                            |
|                                                                             |
|o9 : T                                                                       |
+-----------------------------------------------------------------------------+
|i10 : toE f                                                                  |
|                                                                             |
|       2                    2            2                                   |
|o10 = e  + (2x  + 2a )e  + x  + 2a x  + a                                    |
|       1      1     1  1    1     1 1    1                                   |
|                                                                             |
|o10 : A                                                                      |
+-----------------------------------------------------------------------------+

See also
========

  * toH -- Complete symmetric (h-) basis representation
  * toS -- Schur (s-) basis representation
  * toP -- Power-sum (p-) basis representation

Ways to use toE:
================

  * "toE(RingElement)"

For the programmer
==================

The object toE, is a method function (Macaulay2Doc).

toH -- Complete symmetric (h-) basis representation
***************************************************

Synopsis
========

  * Usage:
        fh = toH f
  * Inputs:
      * f, a ring element (Macaulay2Doc), element of a
        Symmetric or Schur ring
  * Outputs:
      * fh, a ring element (Macaulay2Doc), element of a
        Symmetric ring

Description
===========

Given a symmetric function f, the function toH yields a representation of f as
a polynomial in the complete symmetric functions.

If f is an element of a Schur ring S then the output fh is an element of the
Symmetric ring associated to S (see symmetricRing).

+-------------------------------------------------------+
|i1 : R = symmetricRing 7;                              |
+-------------------------------------------------------+
|i2 : toH(h_3*e_3)                                      |
|                                                       |
|      3                2                               |
|o2 = h h  - 2h h h  + h                                |
|      1 3     1 2 3    3                               |
|                                                       |
|o2 : R                                                 |
+-------------------------------------------------------+
|i3 : S = schurRing(s,4)                                |
|                                                       |
|o3 = S                                                 |
|                                                       |
|o3 : SchurRing                                         |
+-------------------------------------------------------+
|i4 : toH S_{3,2,1}                                     |
|                                                       |
|        6     4       2 2     3                2    2  |
|o4 = - h  + 4h h  - 3h h  - 3h h  + 3h h h  - h  + h h |
|        1     1 2     1 2     1 3     1 2 3    3    1 4|
|                                                       |
|o4 : QQ[e ..e , p ..p , h ..h ]                        |
|         1   4   1   4   1   4                         |
+-------------------------------------------------------+

This also works over tensor products of Symmetric/Schur rings.

+-----------------------------------------------------------------------------+
|i5 : R = schurRing(r, 4, EHPVariables => (a,b,c));                           |
+-----------------------------------------------------------------------------+
|i6 : S = schurRing(R, s, 2, EHPVariables => (x,y,z));                        |
+-----------------------------------------------------------------------------+
|i7 : T = schurRing(S, t, 3);                                                 |
+-----------------------------------------------------------------------------+
|i8 : A = symmetricRing T;                                                    |
+-----------------------------------------------------------------------------+
|i9 : f = (r_1+s_1+t_1)^2                                                     |
|                                                                             |
|o9 = t  + t    + (2r  s  + 2r s  )t  + (s  + s    + 2r s  + (r  +            |
|      2    1,1      () 1     1 ()  1     2    1,1     1 1     2              |
|     ------------------------------------------------------------------------|
|     r   )s  )t                                                              |
|      1,1  ()  ()                                                            |
|                                                                             |
|o9 : T                                                                       |
+-----------------------------------------------------------------------------+
|i10 : toH f                                                                  |
|                                                                             |
|       2                    2            2                                   |
|o10 = h  + (2y  + 2b )h  + y  + 2b y  + b                                    |
|       1      1     1  1    1     1 1    1                                   |
|                                                                             |
|o10 : A                                                                      |
+-----------------------------------------------------------------------------+

See also
========

  * toE -- Elementary symmetric (e-) basis representation
  * toS -- Schur (s-) basis representation
  * toP -- Power-sum (p-) basis representation

Ways to use toH:
================

  * "toH(RingElement)"

For the programmer
==================

The object toH, is a method function (Macaulay2Doc).

toP -- Power-sum (p-) basis representation
******************************************

Synopsis
========

  * Usage:
        fp = toP f
  * Inputs:
      * f, a ring element (Macaulay2Doc), element of a
        Symmetric or Schur ring
  * Outputs:
      * fp, a ring element (Macaulay2Doc), element of a
        Symmetric ring

Description
===========

Given a symmetric function f, the function toP yields a representation of f as
a polynomial in the power-sum symmetric functions.

If f is an element of a Schur ring S then the output fp is an element of the
Symmetric ring associated to S (see symmetricRing).

+-----------------------------------------------------------+
|i1 : R = symmetricRing 7;                                  |
+-----------------------------------------------------------+
|i2 : toP(h_3*e_3)                                          |
|                                                           |
|      1 6   1 2 2   1 3     1 2                            |
|o2 = --p  - -p p  + -p p  + -p                             |
|     36 1   4 1 2   9 1 3   9 3                            |
|                                                           |
|o2 : R                                                     |
+-----------------------------------------------------------+
|i3 : S = schurRing(s,4)                                    |
|                                                           |
|o3 = S                                                     |
|                                                           |
|o3 : SchurRing                                             |
+-----------------------------------------------------------+
|i4 : toP S_{3,2,1}                                         |
|                                                           |
|      1 6    1 4     1 2 2    5 3     1         1 2   1 2  |
|o4 = --p  + --p p  - -p p  - --p p  + -p p p  - -p  + -p p |
|     72 1   12 1 2   8 1 2   18 1 3   6 1 2 3   9 3   4 1 4|
|                                                           |
|o4 : QQ[e ..e , p ..p , h ..h ]                            |
|         1   4   1   4   1   4                             |
+-----------------------------------------------------------+

This also works over tensor products of Symmetric/Schur rings.

+-----------------------------------------------------------------------------+
|i5 : R = schurRing(r, 4, EHPVariables => (a,b,c));                           |
+-----------------------------------------------------------------------------+
|i6 : S = schurRing(R, s, 2, EHPVariables => (x,y,z));                        |
+-----------------------------------------------------------------------------+
|i7 : T = schurRing(S, t, 3);                                                 |
+-----------------------------------------------------------------------------+
|i8 : A = symmetricRing T;                                                    |
+-----------------------------------------------------------------------------+
|i9 : f = (r_1+s_1+t_1)^2                                                     |
|                                                                             |
|o9 = t  + t    + (2r  s  + 2r s  )t  + (s  + s    + 2r s  + (r  +            |
|      2    1,1      () 1     1 ()  1     2    1,1     1 1     2              |
|     ------------------------------------------------------------------------|
|     r   )s  )t                                                              |
|      1,1  ()  ()                                                            |
|                                                                             |
|o9 : T                                                                       |
+-----------------------------------------------------------------------------+
|i10 : toP f                                                                  |
|                                                                             |
|       2                    2            2                                   |
|o10 = p  + (2z  + 2c )p  + z  + 2c z  + c                                    |
|       1      1     1  1    1     1 1    1                                   |
|                                                                             |
|o10 : A                                                                      |
+-----------------------------------------------------------------------------+

See also
========

  * toH -- Complete symmetric (h-) basis representation
  * toS -- Schur (s-) basis representation
  * toE -- Elementary symmetric (e-) basis representation

Ways to use toP:
================

  * "toP(RingElement)"

For the programmer
==================

The object toP, is a method function (Macaulay2Doc).

toS -- Schur (s-) basis representation
**************************************

Synopsis
========

  * Usage:
        fs = toS f
        fs = toS(f,S)

Description
===========

Given a symmetric function f, the function toS yields a representation of f as
a linear combination of Schur functions.

If f is an element of a Symmetric ring R and the output Schur ring S is not
specified, then the output fs is an element of the Schur ring associated to R
(see schurRing).

+-----------------------------+
|i1 : R = symmetricRing(QQ,4);|
+-----------------------------+
|i2 : fs = toS(e_1*h_2+p_3)   |
|                             |
|o2 = 2s  + s                 |
|       3    1,1,1            |
|                             |
|o2 : schurRing (QQ, s, 4)    |
+-----------------------------+
|i3 : S = schurRing(s,2);     |
+-----------------------------+
|i4 : toS(fs,S)               |
|                             |
|o4 = 2s                      |
|       3                     |
|                             |
|o4 : S                       |
+-----------------------------+

This also works over tensor products of Symmetric/Schur rings.

+-----------------------------------------------------------------------------+
|i5 : R = symmetricRing(4, EHPVariables => (a,b,c), SVariable => r);          |
+-----------------------------------------------------------------------------+
|i6 : S = symmetricRing(R, 2, EHPVariables => (x,y,z), SVariable => s);       |
+-----------------------------------------------------------------------------+
|i7 : T = symmetricRing(S, 3, SVariable => t);                                |
+-----------------------------------------------------------------------------+
|i8 : A = schurRing T;                                                        |
+-----------------------------------------------------------------------------+
|i9 : f = a_3*x_2*e_1 - b_1*z_2*p_3                                           |
|                                                                             |
|o9 = - b z p  + a x e                                                        |
|        1 2 3    3 2 1                                                       |
|                                                                             |
|o9 : T                                                                       |
+-----------------------------------------------------------------------------+
|i10 : toS f                                                                  |
|                                                                             |
|o10 = (- r s  + r s   )t  + (r s  - r s   )t    + (- r s  + r s   )t      +  |
|          1 2    1 1,1  3     1 2    1 1,1  2,1       1 2    1 1,1  1,1,1    |
|      -----------------------------------------------------------------------|
|      r     s   t                                                            |
|       1,1,1 1,1 1                                                           |
|                                                                             |
|o10 : A                                                                      |
+-----------------------------------------------------------------------------+

See also
========

  * toH -- Complete symmetric (h-) basis representation
  * toE -- Elementary symmetric (e-) basis representation
  * toP -- Power-sum (p-) basis representation

Ways to use toS:
================

  * "toS(RingElement)"
  * "toS(RingElement,SchurRing)"

For the programmer
==================

The object toS, is a method function (Macaulay2Doc).