Witt symmetric functions#

class sage.combinat.sf.witt.SymmetricFunctionAlgebra_witt(Sym)[source]#

Bases: SymmetricFunctionAlgebra_multiplicative

The Witt symmetric function basis (or Witt basis, to be short).

The Witt basis of the ring of symmetric functions is denoted by \((x_{\lambda})\) in [HazWitt1], section 9.63, and by \((q_{\lambda})\) in [DoranIV1996]. We will denote this basis by \((w_{\lambda})\) (which is precisely how it is denoted in [GriRei18], Exercise 2.9.3(d)). It is a multiplicative basis (meaning that \(w_{\emptyset} = 1\) and that every partition \(\lambda\) satisfies \(w_{\lambda} = w_{\lambda_1} w_{\lambda_2} w_{\lambda_3} \cdots\), where \(w_i\) means \(w_{(i)}\) for every nonnegative integer \(i\)).

This basis can be defined in various ways. Probably the most well-known one is using the equation

\[\prod_{d=1}^{\infty} (1 - w_d t^d)^{-1} = \sum_{n=0}^{\infty} h_n t^n\]

where \(t\) is a formal variable and \(h_n\) are the complete homogeneous symmetric functions, extended to \(0\) by \(h_0 = 1\). This equation allows one to uniquely determine the functions \(w_1, w_2, w_3, \ldots\) by recursion; one consequently extends the definition to all \(w_{\lambda}\) by requiring multiplicativity.

A way to rewrite the above equation without power series is:

\[h_n = \sum_{\lambda \vdash n} w_{\lambda}\]

for all nonnegative integers \(n\), where \(\lambda \vdash n\) means that \(\lambda\) is a partition of \(n\).

A similar equation (which is easily seen to be equivalent to the former) is

\[e_n = \sum_{\lambda} (-1)^{n - \ell(\lambda)} w_{\lambda},\]

with the sum running only over strict partitions \(\lambda\) of \(n\) this time. This equation can also be used to recursively define the \(w_n\). Furthermore, every positive integer \(n\) satisfies

\[p_n = \sum_{d\mid n} d w_d^{n/d},\]

and this can be used to define the \(w_n\) recursively over any ring which is torsion-free as a \(\ZZ\)-module. While these equations all yield easy formulas for classical bases of the ring of symmetric functions in terms of the Witt symmetric functions, it seems difficult to obtain explicit formulas in the other direction.

The Witt symmetric functions owe their name to the fact that the ring of symmetric functions can be viewed as the coordinate ring of the group scheme of Witt vectors, and the Witt symmetric functions are the functions that send a Witt vector to its components (whereas the powersum symmetric functions send a Witt vector to its ghost components). Details can be found in [HazWitt1] or section 3.2 of [BorWi2004].

INPUT:

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

REFERENCES:

[HazWitt1] (1,2)

Michiel Hazewinkel. Witt vectors. Part 1. arXiv 0804.3888v1

[DoranIV1996]

William F. Doran IV. A Proof of Reutenauer’s `-q_{(n)}` Conjecture. Journal of combinatorial theory, Series A 74, pp. 342-344 (1996), article no. 0056. doi:10.1006/jcta.1996.0056

[BorWi2004]

James Borger, Ben Wieland. Plethystic algebra. arXiv math/0407227v1

EXAMPLES:

Here are the first few Witt symmetric functions, in various bases:

sage: Sym = SymmetricFunctions(QQ)
sage: w = Sym.w()
sage: e = Sym.e()
sage: h = Sym.h()
sage: p = Sym.p()
sage: s = Sym.s()
sage: m = Sym.m()

sage: p(w([1]))
p[1]
sage: m(w([1]))
m[1]
sage: e(w([1]))
e[1]
sage: h(w([1]))
h[1]
sage: s(w([1]))
s[1]

sage: p(w([2]))
-1/2*p[1, 1] + 1/2*p[2]
sage: m(w([2]))
-m[1, 1]
sage: e(w([2]))
-e[2]
sage: h(w([2]))
-h[1, 1] + h[2]
sage: s(w([2]))
-s[1, 1]

sage: p(w([3]))
-1/3*p[1, 1, 1] + 1/3*p[3]
sage: m(w([3]))
-2*m[1, 1, 1] - m[2, 1]
sage: e(w([3]))
-e[2, 1] + e[3]
sage: h(w([3]))
-h[2, 1] + h[3]
sage: s(w([3]))
-s[2, 1]

sage: Sym = SymmetricFunctions(ZZ)
sage: w = Sym.w()
sage: e = Sym.e()
sage: h = Sym.h()
sage: s = Sym.s()
sage: m = Sym.m()
sage: p = Sym.p()
sage: m(w([4]))
-9*m[1, 1, 1, 1] - 4*m[2, 1, 1] - 2*m[2, 2] - m[3, 1]
sage: e(w([4]))
-e[2, 1, 1] + e[3, 1] - e[4]
sage: h(w([4]))
-h[1, 1, 1, 1] + 2*h[2, 1, 1] - h[2, 2] - h[3, 1] + h[4]
sage: s(w([4]))
-s[1, 1, 1, 1] - s[2, 1, 1] - s[2, 2] - s[3, 1]

>>> from sage.all import *
>>> Sym = SymmetricFunctions(QQ)
>>> w = Sym.w()
>>> e = Sym.e()
>>> h = Sym.h()
>>> p = Sym.p()
>>> s = Sym.s()
>>> m = Sym.m()

>>> p(w([Integer(1)]))
p[1]
>>> m(w([Integer(1)]))
m[1]
>>> e(w([Integer(1)]))
e[1]
>>> h(w([Integer(1)]))
h[1]
>>> s(w([Integer(1)]))
s[1]

>>> p(w([Integer(2)]))
-1/2*p[1, 1] + 1/2*p[2]
>>> m(w([Integer(2)]))
-m[1, 1]
>>> e(w([Integer(2)]))
-e[2]
>>> h(w([Integer(2)]))
-h[1, 1] + h[2]
>>> s(w([Integer(2)]))
-s[1, 1]

>>> p(w([Integer(3)]))
-1/3*p[1, 1, 1] + 1/3*p[3]
>>> m(w([Integer(3)]))
-2*m[1, 1, 1] - m[2, 1]
>>> e(w([Integer(3)]))
-e[2, 1] + e[3]
>>> h(w([Integer(3)]))
-h[2, 1] + h[3]
>>> s(w([Integer(3)]))
-s[2, 1]

>>> Sym = SymmetricFunctions(ZZ)
>>> w = Sym.w()
>>> e = Sym.e()
>>> h = Sym.h()
>>> s = Sym.s()
>>> m = Sym.m()
>>> p = Sym.p()
>>> m(w([Integer(4)]))
-9*m[1, 1, 1, 1] - 4*m[2, 1, 1] - 2*m[2, 2] - m[3, 1]
>>> e(w([Integer(4)]))
-e[2, 1, 1] + e[3, 1] - e[4]
>>> h(w([Integer(4)]))
-h[1, 1, 1, 1] + 2*h[2, 1, 1] - h[2, 2] - h[3, 1] + h[4]
>>> s(w([Integer(4)]))
-s[1, 1, 1, 1] - s[2, 1, 1] - s[2, 2] - s[3, 1]

Some examples of conversions the other way:

sage: w(h[3])
w[1, 1, 1] + w[2, 1] + w[3]
sage: w(e[3])
-w[2, 1] + w[3]
sage: w(m[2,1])
2*w[2, 1] - 3*w[3]
sage: w(p[3])
w[1, 1, 1] + 3*w[3]

>>> from sage.all import *
>>> w(h[Integer(3)])
w[1, 1, 1] + w[2, 1] + w[3]
>>> w(e[Integer(3)])
-w[2, 1] + w[3]
>>> w(m[Integer(2),Integer(1)])
2*w[2, 1] - 3*w[3]
>>> w(p[Integer(3)])
w[1, 1, 1] + 3*w[3]

Antipodes:

sage: w([1]).antipode()
-w[1]
sage: w([2]).antipode()
-w[1, 1] - w[2]

>>> from sage.all import *
>>> w([Integer(1)]).antipode()
-w[1]
>>> w([Integer(2)]).antipode()
-w[1, 1] - w[2]

The following holds for all odd \(i\) and is easily proven by induction:

sage: all(w([i]).antipode() == -w([i]) for i in range(1, 10, 2))
True

>>> from sage.all import *
>>> all(w([i]).antipode() == -w([i]) for i in range(Integer(1), Integer(10), Integer(2)))
True

The Witt basis does not allow for simple expressions for comultiplication and antipode in general (this is related to the fact that the sum of two Witt vectors isn’t easily described in terms of the components). Therefore, a number of computations with Witt symmetric functions pass through the complete homogeneous symmetric functions by default.

class Element[source]#

Bases: Element

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.

EXAMPLES:

sage: Sym = SymmetricFunctions(QQ)
sage: w = Sym.w()
sage: a = w([4,3,1,1]); a
w[4, 3, 1, 1]
sage: a.omega()
-w[3, 1, 1, 1, 1, 1, 1] - w[3, 2, 1, 1, 1, 1]
 - w[3, 2, 2, 1, 1] - w[4, 3, 1, 1]

sage: h = Sym.h()
sage: all(w(h(w[la]).omega()) == w[la].omega()
....:     for n in range(6) for la in Partitions(n))
True

>>> from sage.all import *
>>> Sym = SymmetricFunctions(QQ)
>>> w = Sym.w()
>>> a = w([Integer(4),Integer(3),Integer(1),Integer(1)]); a
w[4, 3, 1, 1]
>>> a.omega()
-w[3, 1, 1, 1, 1, 1, 1] - w[3, 2, 1, 1, 1, 1]
 - w[3, 2, 2, 1, 1] - w[4, 3, 1, 1]

>>> h = Sym.h()
>>> all(w(h(w[la]).omega()) == w[la].omega()
...     for n in range(Integer(6)) for la in Partitions(n))
True
coproduct(elt)[source]#

Return the coproduct of the element elt.

INPUT:

  • elt – a symmetric function written in this basis

OUTPUT:

The coproduct acting on elt; the result is an element of the tensor squared of the basis self.

EXAMPLES:

sage: w = SymmetricFunctions(QQ).w()
sage: w[2].coproduct()
w[] # w[2] - w[1] # w[1] + w[2] # w[]
sage: w.coproduct(w[2])
w[] # w[2] - w[1] # w[1] + w[2] # w[]
sage: w[2,1].coproduct()
w[] # w[2, 1] - w[1] # w[1, 1] + w[1] # w[2] - w[1, 1] # w[1] + w[2] # w[1] + w[2, 1] # w[]
sage: w.coproduct(w[2,1])
w[] # w[2, 1] - w[1] # w[1, 1] + w[1] # w[2] - w[1, 1] # w[1] + w[2] # w[1] + w[2, 1] # w[]

>>> from sage.all import *
>>> w = SymmetricFunctions(QQ).w()
>>> w[Integer(2)].coproduct()
w[] # w[2] - w[1] # w[1] + w[2] # w[]
>>> w.coproduct(w[Integer(2)])
w[] # w[2] - w[1] # w[1] + w[2] # w[]
>>> w[Integer(2),Integer(1)].coproduct()
w[] # w[2, 1] - w[1] # w[1, 1] + w[1] # w[2] - w[1, 1] # w[1] + w[2] # w[1] + w[2, 1] # w[]
>>> w.coproduct(w[Integer(2),Integer(1)])
w[] # w[2, 1] - w[1] # w[1, 1] + w[1] # w[2] - w[1, 1] # w[1] + w[2] # w[1] + w[2, 1] # w[]
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}, \quad \mathbf{V}_n(w_r) = w_{r/n},\]

(where \(h\) is the complete homogeneous basis, \(p\) is the powersum basis, \(e\) is the elementary basis, and \(w\) is the Witt 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) = \mathbf{V}_n(w_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 – a 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: w = Sym.w()
sage: w[3].verschiebung(2)
0
sage: w[4].verschiebung(4)
w[1]

>>> from sage.all import *
>>> Sym = SymmetricFunctions(ZZ)
>>> w = Sym.w()
>>> w[Integer(3)].verschiebung(Integer(2))
0
>>> w[Integer(4)].verschiebung(Integer(4))
w[1]