### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Symmetric Functions »

# Schur symmetric functions

class `sage.combinat.sf.schur.``SymmetricFunctionAlgebra_schur`(Sym)

  Bases: `sage.combinat.sf.classical.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

  TESTS:

      sage: s = SymmetricFunctions(QQ).s()
      sage: s == loads(dumps(s))
      True
      sage: TestSuite(s).run(skip=['_test_associativity', '_test_distributivity', '_test_prod'])
      sage: TestSuite(s).run(elements = [s[1,1]+s[2], s[1]+2*s[1,1]])

  class `Element`(M, x)

    Bases: `sage.combinat.sf.classical.SymmetricFunctionAlgebra_classical.Element`

    Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s `__call__()` method.

    TESTS:

        sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
        sage: B = F.basis()
        sage: f = B['a'] + 3*B['c']; f
        B['a'] + 3*B['c']
        sage: f == loads(dumps(f))
        True

    `expand`(n, alphabet='x')

      Expands the symmetric function as a symmetric polynomial in \(n\) variables.

      INPUT:

      - `self` – an element of the Schur symmetric function basis
      - `n` – a positive integer
      - `alphabet` – a variable for the expansion (default: \(x\))

      OUTPUT: a monomial expansion of an instance of `self` in \(n\) variables

      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

    `omega`()

      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]

    `omega_involution`()

      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]

    `scalar`(x, zee=None)

      Returns 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` – an element of the symmetric functions
      - `zee` – an optional function that specifies the scalar product between two power sum symmetric functions indexed by the same partition. If `zee` is not specified.

      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

          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]

    `verschiebung`(n)

      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` – 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: 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[]

      TESTS:

      Let us check that this method on the powersum basis gives the same result as the implementation in sfa.py on the monomial basis:

          sage: Sym = SymmetricFunctions(QQ)
          sage: s = Sym.s(); h = Sym.h()
          sage: all( h(s(lam)).verschiebung(3) == h(s(lam).verschiebung(3))
          ....:      for lam in Partitions(6) )
          True
          sage: all( s(h(lam)).verschiebung(2) == s(h(lam).verschiebung(2))
          ....:      for lam in Partitions(4) )
          True
          sage: all( s(h(lam)).verschiebung(5) == s(h(lam).verschiebung(5))
          ....:      for lam in Partitions(10) )
          True
          sage: all( s(h(lam)).verschiebung(2) == s(h(lam).verschiebung(2))
          ....:      for lam in Partitions(8) )
          True
          sage: all( s(h(lam)).verschiebung(3) == s(h(lam).verschiebung(3))
          ....:      for lam in Partitions(12) )
          True
          sage: all( s(h(lam)).verschiebung(3) == s(h(lam).verschiebung(3))
          ....:      for lam in Partitions(9) )
          True

  `SymmetricFunctionAlgebra_schur.``coproduct_on_basis`(mu)

    Returns 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[]

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Symmetric Functions »