Schur symmetric functions

class sage.combinat.sf.schur.SymmetricFunctionAlgebra_schur(Sym)[source]

Bases: SymmetricFunctionAlgebra_classical

A class for methods related to the Schur symmetric function basis.

INPUT:

  • self – a Schur symmetric function basis

  • Sym – an instance of the ring of the symmetric functions

class Element[source]

Bases: Element

expand(n, alphabet='x')[source]

Expand the symmetric function self as a symmetric polynomial in n variables.

INPUT:

  • n – nonnegative integer

  • alphabet – (default: 'x') a variable for the expansion

OUTPUT:

A monomial expansion of self in the \(n\) variables labelled by alphabet.

EXAMPLES:

sage: s = SymmetricFunctions(QQ).s()
sage: a = s([2,1])
sage: a.expand(2)
x0^2*x1 + x0*x1^2
sage: a.expand(3)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2
sage: a.expand(4)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x0^2*x3 + 2*x0*x1*x3 + x1^2*x3 + 2*x0*x2*x3 + 2*x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2
sage: a.expand(2, alphabet='y')
y0^2*y1 + y0*y1^2
sage: a.expand(2, alphabet=['a','b'])
a^2*b + a*b^2
sage: s([1,1,1,1]).expand(3)
0
sage: (s([]) + 2*s([1])).expand(3)
2*x0 + 2*x1 + 2*x2 + 1
sage: s([1]).expand(0)
0
sage: (3*s([])).expand(0)
3

>>> from sage.all import *
>>> s = SymmetricFunctions(QQ).s()
>>> a = s([Integer(2),Integer(1)])
>>> a.expand(Integer(2))
x0^2*x1 + x0*x1^2
>>> a.expand(Integer(3))
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2
>>> a.expand(Integer(4))
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x0^2*x3 + 2*x0*x1*x3 + x1^2*x3 + 2*x0*x2*x3 + 2*x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2
>>> a.expand(Integer(2), alphabet='y')
y0^2*y1 + y0*y1^2
>>> a.expand(Integer(2), alphabet=['a','b'])
a^2*b + a*b^2
>>> s([Integer(1),Integer(1),Integer(1),Integer(1)]).expand(Integer(3))
0
>>> (s([]) + Integer(2)*s([Integer(1)])).expand(Integer(3))
2*x0 + 2*x1 + 2*x2 + 1
>>> s([Integer(1)]).expand(Integer(0))
0
>>> (Integer(3)*s([])).expand(Integer(0))
3
exponential_specialization(t=None, q=1)[source]

Return the exponential specialization of a symmetric function (when \(q = 1\)), or the \(q\)-exponential specialization (when \(q \neq 1\)).

The exponential specialization \(ex\) at \(t\) is a \(K\)-algebra homomorphism from the \(K\)-algebra of symmetric functions to another \(K\)-algebra \(R\). It is defined whenever the base ring \(K\) is a \(\QQ\)-algebra and \(t\) is an element of \(R\). The easiest way to define it is by specifying its values on the powersum symmetric functions to be \(p_1 = t\) and \(p_n = 0\) for \(n > 1\). Equivalently, on the homogeneous functions it is given by \(ex(h_n) = t^n / n!\); see Proposition 7.8.4 of [EnumComb2].

By analogy, the \(q\)-exponential specialization is a \(K\)-algebra homomorphism from the \(K\)-algebra of symmetric functions to another \(K\)-algebra \(R\) that depends on two elements \(t\) and \(q\) of \(R\) for which the elements \(1 - q^i\) for all positive integers \(i\) are invertible. It can be defined by specifying its values on the complete homogeneous symmetric functions to be

\[ex_q(h_n) = t^n / [n]_q!,\]

where \([n]_q!\) is the \(q\)-factorial. Equivalently, for \(q \neq 1\) and a homogeneous symmetric function \(f\) of degree \(n\), we have

\[ex_q(f) = (1-q)^n t^n ps_q(f),\]

where \(ps_q(f)\) is the stable principal specialization of \(f\) (see principal_specialization()). (See (7.29) in [EnumComb2].)

The limit of \(ex_q\) as \(q \to 1\) is \(ex\).

INPUT:

  • t – (default: None) the value to use for \(t\); the default is to create a ring of polynomials in t

  • q – (default: \(1\)) the value to use for \(q\). If q is None, then a ring (or fraction field) of polynomials in q is created.

We use the formula in the proof of Corollary 7.21.6 of [EnumComb2]

\[ex_{q}(s_\lambda) = t^{|\lambda|} q^{\sum_i (i-1)\lambda_i} / \prod_{u\in\lambda} (1 + q + q^2 + \dots + q^{h(u)-1})\]

where \(h(u)\) is the hook length of a cell \(u\) in \(\lambda\).

As a limit case, we obtain a formula for \(q=1\)

\[ex_{1}(s_\lambda) = f^\lambda t^{|\lambda|} / |\lambda|!\]

where \(f^\lambda\) is the number of standard Young tableaux of shape \(\lambda\).

EXAMPLES:

sage: s = SymmetricFunctions(QQ).s()
sage: x = s[5,3]
sage: x.exponential_specialization()
1/1440*t^8

sage: x = 5*s[1,1,1] + 3*s[2,1] + 1
sage: x.exponential_specialization()
11/6*t^3 + 1

>>> from sage.all import *
>>> s = SymmetricFunctions(QQ).s()
>>> x = s[Integer(5),Integer(3)]
>>> x.exponential_specialization()
1/1440*t^8

>>> x = Integer(5)*s[Integer(1),Integer(1),Integer(1)] + Integer(3)*s[Integer(2),Integer(1)] + Integer(1)
>>> x.exponential_specialization()
11/6*t^3 + 1

We also support the \(q\)-exponential_specialization:

sage: factor(s[3].exponential_specialization(q=var("q"), t=var("t")))   # needs sage.symbolic
t^3/((q^2 + q + 1)*(q + 1))

>>> from sage.all import *
>>> factor(s[Integer(3)].exponential_specialization(q=var("q"), t=var("t")))   # needs sage.symbolic
t^3/((q^2 + q + 1)*(q + 1))
omega()[source]

Return the image of self under the omega automorphism.

The omega automorphism is defined to be the unique algebra endomorphism \(\omega\) of the ring of symmetric functions that satisfies \(\omega(e_k) = h_k\) for all positive integers \(k\) (where \(e_k\) stands for the \(k\)-th elementary symmetric function, and \(h_k\) stands for the \(k\)-th complete homogeneous symmetric function). It furthermore is a Hopf algebra endomorphism and an involution, and it is also known as the omega involution. It sends the power-sum symmetric function \(p_k\) to \((-1)^{k-1} p_k\) for every positive integer \(k\).

The images of some bases under the omega automorphism are given by

\[\omega(e_{\lambda}) = h_{\lambda}, \qquad \omega(h_{\lambda}) = e_{\lambda}, \qquad \omega(p_{\lambda}) = (-1)^{|\lambda| - \ell(\lambda)} p_{\lambda}, \qquad \omega(s_{\lambda}) = s_{\lambda^{\prime}},\]

where \(\lambda\) is any partition, where \(\ell(\lambda)\) denotes the length (length()) of the partition \(\lambda\), where \(\lambda^{\prime}\) denotes the conjugate partition (conjugate()) of \(\lambda\), and where the usual notations for bases are used (\(e\) = elementary, \(h\) = complete homogeneous, \(p\) = powersum, \(s\) = Schur).

omega_involution() is a synonym for the omega() method.

OUTPUT: the image of self under the omega automorphism

EXAMPLES:

sage: s = SymmetricFunctions(QQ).s()
sage: s([2,1]).omega()
s[2, 1]
sage: s([2,1,1]).omega()
s[3, 1]

>>> from sage.all import *
>>> s = SymmetricFunctions(QQ).s()
>>> s([Integer(2),Integer(1)]).omega()
s[2, 1]
>>> s([Integer(2),Integer(1),Integer(1)]).omega()
s[3, 1]
omega_involution()[source]

Return the image of self under the omega automorphism.

The omega automorphism is defined to be the unique algebra endomorphism \(\omega\) of the ring of symmetric functions that satisfies \(\omega(e_k) = h_k\) for all positive integers \(k\) (where \(e_k\) stands for the \(k\)-th elementary symmetric function, and \(h_k\) stands for the \(k\)-th complete homogeneous symmetric function). It furthermore is a Hopf algebra endomorphism and an involution, and it is also known as the omega involution. It sends the power-sum symmetric function \(p_k\) to \((-1)^{k-1} p_k\) for every positive integer \(k\).

The images of some bases under the omega automorphism are given by

\[\omega(e_{\lambda}) = h_{\lambda}, \qquad \omega(h_{\lambda}) = e_{\lambda}, \qquad \omega(p_{\lambda}) = (-1)^{|\lambda| - \ell(\lambda)} p_{\lambda}, \qquad \omega(s_{\lambda}) = s_{\lambda^{\prime}},\]

where \(\lambda\) is any partition, where \(\ell(\lambda)\) denotes the length (length()) of the partition \(\lambda\), where \(\lambda^{\prime}\) denotes the conjugate partition (conjugate()) of \(\lambda\), and where the usual notations for bases are used (\(e\) = elementary, \(h\) = complete homogeneous, \(p\) = powersum, \(s\) = Schur).

omega_involution() is a synonym for the omega() method.

OUTPUT: the image of self under the omega automorphism

EXAMPLES:

sage: s = SymmetricFunctions(QQ).s()
sage: s([2,1]).omega()
s[2, 1]
sage: s([2,1,1]).omega()
s[3, 1]

>>> from sage.all import *
>>> s = SymmetricFunctions(QQ).s()
>>> s([Integer(2),Integer(1)]).omega()
s[2, 1]
>>> s([Integer(2),Integer(1),Integer(1)]).omega()
s[3, 1]
principal_specialization(n=+Infinity, q=None)[source]

Return the principal specialization of a symmetric function.

The principal specialization of order \(n\) at \(q\) is the ring homomorphism \(ps_{n,q}\) from the ring of symmetric functions to another commutative ring \(R\) given by \(x_i \mapsto q^{i-1}\) for \(i \in \{1,\dots,n\}\) and \(x_i \mapsto 0\) for \(i > n\). Here, \(q\) is a given element of \(R\), and we assume that the variables of our symmetric functions are \(x_1, x_2, x_3, \ldots\). (To be more precise, \(ps_{n,q}\) is a \(K\)-algebra homomorphism, where \(K\) is the base ring.) See Section 7.8 of [EnumComb2].

The stable principal specialization at \(q\) is the ring homomorphism \(ps_q\) from the ring of symmetric functions to another commutative ring \(R\) given by \(x_i \mapsto q^{i-1}\) for all \(i\). This is well-defined only if the resulting infinite sums converge; thus, in particular, setting \(q = 1\) in the stable principal specialization is an invalid operation.

INPUT:

  • n – (default: infinity) a nonnegative integer or infinity, specifying whether to compute the principal specialization of order n or the stable principal specialization.

  • q – (default: None) the value to use for \(q\); the default is to create a ring of polynomials in q (or a field of rational functions in q) over the given coefficient ring.

For \(q=1\) we use the formula from Corollary 7.21.4 of [EnumComb2]:

\[ps_{n,1}(s_\lambda) = \prod_{u\in\lambda} (n+c(u)) / h(u),\]

where \(h(u)\) is the hook length of a cell \(u\) in \(\lambda\), and where \(c(u)\) is the content of a cell \(u\) in \(\lambda\).

For \(n=infinity\) we use the formula from Corollary 7.21.3 of [EnumComb2]

\[ps_q(s_\lambda) = q^{\sum_i (i-1)\lambda_i} / \prod_{u\in\lambda} (1-q^{h(u)}).\]

Otherwise, we use the formula from Theorem 7.21.2 of [EnumComb2],

\[ps_{n,q}(s_\lambda) = q^{\sum_i (i-1)\lambda_i} \prod_{u\in\lambda} (1-q^{n+c(u)})/(1-q^{h(u)}).\]

EXAMPLES:

sage: s = SymmetricFunctions(QQ).s()
sage: x = s[2]
sage: x.principal_specialization(3)
q^4 + q^3 + 2*q^2 + q + 1

sage: x = 3*s[2,2] + 2*s[1] + 1
sage: x.principal_specialization(3, q=var("q"))                         # needs sage.symbolic
3*(q^4 - 1)*(q^3 - 1)*q^2/((q^2 - 1)*(q - 1)) + 2*(q^3 - 1)/(q - 1) + 1

sage: x.principal_specialization(q=var("q"))                            # needs sage.symbolic
-2/(q - 1) + 3*q^2/((q^3 - 1)*(q^2 - 1)^2*(q - 1)) + 1

>>> from sage.all import *
>>> s = SymmetricFunctions(QQ).s()
>>> x = s[Integer(2)]
>>> x.principal_specialization(Integer(3))
q^4 + q^3 + 2*q^2 + q + 1

>>> x = Integer(3)*s[Integer(2),Integer(2)] + Integer(2)*s[Integer(1)] + Integer(1)
>>> x.principal_specialization(Integer(3), q=var("q"))                         # needs sage.symbolic
3*(q^4 - 1)*(q^3 - 1)*q^2/((q^2 - 1)*(q - 1)) + 2*(q^3 - 1)/(q - 1) + 1

>>> x.principal_specialization(q=var("q"))                            # needs sage.symbolic
-2/(q - 1) + 3*q^2/((q^3 - 1)*(q^2 - 1)^2*(q - 1)) + 1
scalar(x, zee=None)[source]

Return the standard scalar product between self and \(x\).

Note that the Schur functions are self-dual with respect to this scalar product. They are also lower-triangularly related to the monomial symmetric functions with respect to this scalar product.

INPUT:

  • x – element of the ring of symmetric functions over the same base ring as self

  • zee – an optional function on partitions giving the value for the scalar product between the power-sum symmetric function \(p_{\mu}\) and itself (the default value is the standard zee() function)

OUTPUT: the scalar product between self and x

EXAMPLES:

sage: s = SymmetricFunctions(ZZ).s()
sage: a = s([2,1])
sage: b = s([1,1,1])
sage: c = 2*s([1,1,1])
sage: d = a + b
sage: a.scalar(a)
1
sage: b.scalar(b)
1
sage: b.scalar(a)
0
sage: b.scalar(c)
2
sage: c.scalar(c)
4
sage: d.scalar(a)
1
sage: d.scalar(b)
1
sage: d.scalar(c)
2

>>> from sage.all import *
>>> s = SymmetricFunctions(ZZ).s()
>>> a = s([Integer(2),Integer(1)])
>>> b = s([Integer(1),Integer(1),Integer(1)])
>>> c = Integer(2)*s([Integer(1),Integer(1),Integer(1)])
>>> d = a + b
>>> a.scalar(a)
1
>>> b.scalar(b)
1
>>> b.scalar(a)
0
>>> b.scalar(c)
2
>>> c.scalar(c)
4
>>> d.scalar(a)
1
>>> d.scalar(b)
1
>>> d.scalar(c)
2


sage: m = SymmetricFunctions(ZZ).monomial()
sage: p4 = Partitions(4)
sage: l = [ [s(p).scalar(m(q)) for q in p4] for p in p4]
sage: matrix(l)
[ 1  0  0  0  0]
[-1  1  0  0  0]
[ 0 -1  1  0  0]
[ 1 -1 -1  1  0]
[-1  2  1 -3  1]

>>> from sage.all import *
>>> m = SymmetricFunctions(ZZ).monomial()
>>> p4 = Partitions(Integer(4))
>>> l = [ [s(p).scalar(m(q)) for q in p4] for p in p4]
>>> matrix(l)
[ 1  0  0  0  0]
[-1  1  0  0  0]
[ 0 -1  1  0  0]
[ 1 -1 -1  1  0]
[-1  2  1 -3  1]
verschiebung(n)[source]

Return the image of the symmetric function self under the \(n\)-th Verschiebung operator.

The \(n\)-th Verschiebung operator \(\mathbf{V}_n\) is defined to be the unique algebra endomorphism \(V\) of the ring of symmetric functions that satisfies \(V(h_r) = h_{r/n}\) for every positive integer \(r\) divisible by \(n\), and satisfies \(V(h_r) = 0\) for every positive integer \(r\) not divisible by \(n\). This operator \(\mathbf{V}_n\) is a Hopf algebra endomorphism. For every nonnegative integer \(r\) with \(n \mid r\), it satisfies

\[\mathbf{V}_n(h_r) = h_{r/n}, \quad \mathbf{V}_n(p_r) = n p_{r/n}, \quad \mathbf{V}_n(e_r) = (-1)^{r - r/n} e_{r/n}\]

(where \(h\) is the complete homogeneous basis, \(p\) is the powersum basis, and \(e\) is the elementary basis). For every nonnegative integer \(r\) with \(n \nmid r\), it satisfes

\[\mathbf{V}_n(h_r) = \mathbf{V}_n(p_r) = \mathbf{V}_n(e_r) = 0.\]

The \(n\)-th Verschiebung operator is also called the \(n\)-th Verschiebung endomorphism. Its name derives from the Verschiebung (German for “shift”) endomorphism of the Witt vectors.

The \(n\)-th Verschiebung operator is adjoint to the \(n\)-th Frobenius operator (see frobenius() for its definition) with respect to the Hall scalar product (scalar()).

The action of the \(n\)-th Verschiebung operator on the Schur basis can also be computed explicitly. The following (probably clumsier than necessary) description can be obtained by solving exercise 7.61 in Stanley’s [STA].

Let \(\lambda\) be a partition. Let \(n\) be a positive integer. If the \(n\)-core of \(\lambda\) is nonempty, then \(\mathbf{V}_n(s_\lambda) = 0\). Otherwise, the following method computes \(\mathbf{V}_n(s_\lambda)\): Write the partition \(\lambda\) in the form \((\lambda_1, \lambda_2, \ldots, \lambda_{ns})\) for some nonnegative integer \(s\). (If \(n\) does not divide the length of \(\lambda\), then this is achieved by adding trailing zeroes to \(\lambda\).) Set \(\beta_i = \lambda_i + ns - i\) for every \(s \in \{ 1, 2, \ldots, ns \}\). Then, \((\beta_1, \beta_2, \ldots, \beta_{ns})\) is a strictly decreasing sequence of nonnegative integers. Stably sort the list \((1, 2, \ldots, ns)\) in order of (weakly) increasing remainder of \(-1 - \beta_i\) modulo \(n\). Let \(\xi\) be the sign of the permutation that is used for this sorting. Let \(\psi\) be the sign of the permutation that is used to stably sort the list \((1, 2, \ldots, ns)\) in order of (weakly) increasing remainder of \(i - 1\) modulo \(n\). (Notice that \(\psi = (-1)^{n(n-1)s(s-1)/4}\).) Then, \(\mathbf{V}_n(s_\lambda) = \xi \psi \prod_{i = 0}^{n - 1} s_{\lambda^{(i)}}\), where \((\lambda^{(0)}, \lambda^{(1)}, \ldots, \lambda^{(n - 1)})\) is the \(n\)-quotient of \(\lambda\).

INPUT:

  • n – positive integer

OUTPUT:

The result of applying the \(n\)-th Verschiebung operator (on the ring of symmetric functions) to self.

EXAMPLES:

sage: Sym = SymmetricFunctions(ZZ)
sage: s = Sym.s()
sage: s[5].verschiebung(2)
0
sage: s[6].verschiebung(6)
s[1]
sage: s[6,3].verschiebung(3)
s[2, 1] + s[3]
sage: s[6,3,1].verschiebung(2)
-s[3, 2]
sage: s[3,2,1].verschiebung(1)
s[3, 2, 1]
sage: s([]).verschiebung(1)
s[]
sage: s([]).verschiebung(4)
s[]

>>> from sage.all import *
>>> Sym = SymmetricFunctions(ZZ)
>>> s = Sym.s()
>>> s[Integer(5)].verschiebung(Integer(2))
0
>>> s[Integer(6)].verschiebung(Integer(6))
s[1]
>>> s[Integer(6),Integer(3)].verschiebung(Integer(3))
s[2, 1] + s[3]
>>> s[Integer(6),Integer(3),Integer(1)].verschiebung(Integer(2))
-s[3, 2]
>>> s[Integer(3),Integer(2),Integer(1)].verschiebung(Integer(1))
s[3, 2, 1]
>>> s([]).verschiebung(Integer(1))
s[]
>>> s([]).verschiebung(Integer(4))
s[]
coproduct_on_basis(mu)[source]

Return the coproduct of self(mu).

Here self is the basis of Schur functions in the ring of symmetric functions.

INPUT:

  • self – a Schur symmetric function basis

  • mu – a partition

OUTPUT:

  • the image of the mu-th Schur function under the comultiplication of the Hopf algebra of symmetric functions; this is an element of the tensor square of the Schur basis

EXAMPLES:

sage: Sym = SymmetricFunctions(QQ)
sage: s = Sym.schur()
sage: s.coproduct_on_basis([2])
s[] # s[2] + s[1] # s[1] + s[2] # s[]

>>> from sage.all import *
>>> Sym = SymmetricFunctions(QQ)
>>> s = Sym.schur()
>>> s.coproduct_on_basis([Integer(2)])
s[] # s[2] + s[1] # s[1] + s[2] # s[]
product_on_basis(left, right)[source]

Return the product of left and right.

INPUT:

  • self – a Schur symmetric function basis

  • left, right – partitions

OUTPUT: an element of the Schur basis, the product of left and right