Generic dual bases symmetric functions - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# Generic dual bases symmetric functions

class sage.combinat.sf.dual.DualBasisFunctor(basis)

  Bases: `SymmetricFunctionsFunctor`

  A constructor for algebras of symmetric functions constructed by duality.

  EXAMPLES:

  Sage

      sage: w = SymmetricFunctions(ZZ).witt()
      sage: w.dual_basis().construction()
      (SymmetricFunctionsFunctor[dual Witt], Integer Ring)

  Python

      >>> from sage.all import *
      >>> w = SymmetricFunctions(ZZ).witt()
      >>> w.dual_basis().construction()
      (SymmetricFunctionsFunctor[dual Witt], Integer Ring)

class sage.combinat.sf.dual.SymmetricFunctionAlgebra_dual(dual_basis, scalar, scalar_name, basis_name, prefix)

  Bases: `SymmetricFunctionAlgebra_classical`

  Generic dual basis of a basis of symmetric functions.

  INPUT:

  - `dual_basis` – a basis of the ring of symmetric functions

  - `scalar` – a function \(z\) on partitions which determines the scalar product on the power sum basis by \(\langle p_{\mu}, p_{\mu} \rangle = z(\mu)\). (Independently on the function chosen, the power sum basis will always be orthogonal; the function `scalar` only determines the norms of the basis elements.) This defaults to the function `zee` defined in `sage.combinat.sf.sfa`, that is, the function is defined by:

    \[\lambda \mapsto \prod_{i = 1}^\infty m_i(\lambda)! i^{m_i(\lambda)}`,\]

    where \(m_i(\lambda)\) means the number of times \(i\) appears in \(\lambda\). This default function gives the standard Hall scalar product on the ring of symmetric functions.

  - `scalar_name` – (default: the empty string) a string giving a description of the scalar product specified by the parameter `scalar`

  - `basis_name` – (optional) a string to serve as name for the basis to be generated (such as “forgotten” in “the forgotten basis”); don’t set it to any of the already existing basis names (such as `homogeneous`, `monomial`, `forgotten`, etc.).

  - `prefix` – (default: `'d'` and the prefix for `dual_basis`) a string to use as the symbol for the basis

  OUTPUT:

  The basis of the ring of symmetric functions dual to the basis `dual_basis` with respect to the scalar product determined by `scalar`.

  EXAMPLES:

  Sage

      sage: e = SymmetricFunctions(QQ).e()
      sage: f = e.dual_basis(prefix='m', basis_name="Forgotten symmetric functions"); f
      Symmetric Functions over Rational Field in the Forgotten symmetric functions basis
      sage: TestSuite(f).run(elements=[f[1,1]+2*f[2], f[1]+3*f[1,1]])
      sage: TestSuite(f).run() # long time (11s on sage.math, 2011)

  Python

      >>> from sage.all import *
      >>> e = SymmetricFunctions(QQ).e()
      >>> f = e.dual_basis(prefix='m', basis_name="Forgotten symmetric functions"); f
      Symmetric Functions over Rational Field in the Forgotten symmetric functions basis
      >>> TestSuite(f).run(elements=[f[Integer(1),Integer(1)]+Integer(2)*f[Integer(2)], f[Integer(1)]+Integer(3)*f[Integer(1),Integer(1)]])
      >>> TestSuite(f).run() # long time (11s on sage.math, 2011)

  This class defines canonical coercions between `self` and `self^*`, as follow:

  Lookup for the canonical isomorphism from `self` to \(P\) (=powersum), and build the adjoint isomorphism from \(P^*\) to `self^*`. Since \(P\) is self-adjoint for this scalar product, derive an isomorphism from \(P\) to `self^*`, and by composition with the above get an isomorphism from `self` to `self^*` (and similarly for the isomorphism `self^*` to `self`).

  This should be striped down to just (auto?) defining canonical isomorphism by adjunction (as in MuPAD-Combinat), and let the coercion handle the rest.

  Inversions may not be possible if the base ring is not a field:

  Sage

      sage: m = SymmetricFunctions(ZZ).m()
      sage: h = m.dual_basis(lambda x: 1)
      sage: h[2,1]
      Traceback (most recent call last):
      ...
      TypeError: no conversion of this rational to integer

  [Python]

      >>> from sage.all import *
      >>> m = SymmetricFunctions(ZZ).m()
      >>> h = m.dual_basis(lambda x: Integer(1))
      >>> h[Integer(2),Integer(1)]
      Traceback (most recent call last):
      ...
      TypeError: no conversion of this rational to integer

  By transitivity, this defines indirect coercions to and from all other bases:

  Sage

      sage: s = SymmetricFunctions(QQ['t'].fraction_field()).s()
      sage: t = QQ['t'].fraction_field().gen()
      sage: zee_hl = lambda x: x.centralizer_size(t=t)
      sage: S = s.dual_basis(zee_hl)
      sage: S(s([2,1]))
      (-t/(t^5-2*t^4+t^3-t^2+2*t-1))*d_s[1, 1, 1] + ((-t^2-1)/(t^5-2*t^4+t^3-t^2+2*t-1))*d_s[2, 1] + (-t/(t^5-2*t^4+t^3-t^2+2*t-1))*d_s[3]

  Python

      >>> from sage.all import *
      >>> s = SymmetricFunctions(QQ['t'].fraction_field()).s()
      >>> t = QQ['t'].fraction_field().gen()
      >>> zee_hl = lambda x: x.centralizer_size(t=t)
      >>> S = s.dual_basis(zee_hl)
      >>> S(s([Integer(2),Integer(1)]))
      (-t/(t^5-2*t^4+t^3-t^2+2*t-1))*d_s[1, 1, 1] + ((-t^2-1)/(t^5-2*t^4+t^3-t^2+2*t-1))*d_s[2, 1] + (-t/(t^5-2*t^4+t^3-t^2+2*t-1))*d_s[3]

  class Element(A, dictionary=None, dual=None)

    Bases: `Element`

    An element in the dual basis.

    INPUT:

    At least one of the following must be specified. The one (if any) which is not provided will be computed.

    - `dictionary` – an internal dictionary for the monomials and coefficients of `self`

    - `dual` – self as an element of the dual basis

    dual()

      Return `self` in the dual basis.

      OUTPUT:

      - the element `self` expanded in the dual basis to `self.parent()`

      EXAMPLES:

      Sage

          sage: m = SymmetricFunctions(QQ).monomial()
          sage: zee = sage.combinat.sf.sfa.zee
          sage: h = m.dual_basis(scalar=zee)
          sage: a = h([2,1])
          sage: a.parent()
          Dual basis to Symmetric Functions over Rational Field in the monomial basis
          sage: a.dual()
          3*m[1, 1, 1] + 2*m[2, 1] + m[3]

      Python

          >>> from sage.all import *
          >>> m = SymmetricFunctions(QQ).monomial()
          >>> zee = sage.combinat.sf.sfa.zee
          >>> h = m.dual_basis(scalar=zee)
          >>> a = h([Integer(2),Integer(1)])
          >>> a.parent()
          Dual basis to Symmetric Functions over Rational Field in the monomial basis
          >>> a.dual()
          3*m[1, 1, 1] + 2*m[2, 1] + m[3]

    expand(n, alphabet='x')

      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

          sage: m = SymmetricFunctions(QQ).monomial()
          sage: zee = sage.combinat.sf.sfa.zee
          sage: h = m.dual_basis(zee)
          sage: a = h([2,1])+h([3])
          sage: a.expand(2)
          2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
          sage: a.dual().expand(2)
          2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
          sage: a.expand(2,alphabet='y')
          2*y0^3 + 3*y0^2*y1 + 3*y0*y1^2 + 2*y1^3
          sage: a.expand(2,alphabet='x,y')
          2*x^3 + 3*x^2*y + 3*x*y^2 + 2*y^3
          sage: h([1]).expand(0)
          0
          sage: (3*h([])).expand(0)
          3

      Python

          >>> from sage.all import *
          >>> m = SymmetricFunctions(QQ).monomial()
          >>> zee = sage.combinat.sf.sfa.zee
          >>> h = m.dual_basis(zee)
          >>> a = h([Integer(2),Integer(1)])+h([Integer(3)])
          >>> a.expand(Integer(2))
          2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
          >>> a.dual().expand(Integer(2))
          2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
          >>> a.expand(Integer(2),alphabet='y')
          2*y0^3 + 3*y0^2*y1 + 3*y0*y1^2 + 2*y1^3
          >>> a.expand(Integer(2),alphabet='x,y')
          2*x^3 + 3*x^2*y + 3*x*y^2 + 2*y^3
          >>> h([Integer(1)]).expand(Integer(0))
          0
          >>> (Integer(3)*h([])).expand(Integer(0))
          3

    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 result of applying omega to `self`

      EXAMPLES:

      Sage

          sage: m = SymmetricFunctions(QQ).monomial()
          sage: zee = sage.combinat.sf.sfa.zee
          sage: h = m.dual_basis(zee)
          sage: hh = SymmetricFunctions(QQ).homogeneous()
          sage: hh([2,1]).omega()
          h[1, 1, 1] - h[2, 1]
          sage: h([2,1]).omega()
          d_m[1, 1, 1] - d_m[2, 1]

      Python

          >>> from sage.all import *
          >>> m = SymmetricFunctions(QQ).monomial()
          >>> zee = sage.combinat.sf.sfa.zee
          >>> h = m.dual_basis(zee)
          >>> hh = SymmetricFunctions(QQ).homogeneous()
          >>> hh([Integer(2),Integer(1)]).omega()
          h[1, 1, 1] - h[2, 1]
          >>> h([Integer(2),Integer(1)]).omega()
          d_m[1, 1, 1] - d_m[2, 1]

    omega_involution()

      alias of `omega()`.

    scalar(x)

      Return the standard scalar product of `self` and `x`.

      INPUT:

      - `x` – element of the symmetric functions

      OUTPUT: the scalar product between `x` and `self`

      EXAMPLES:

      Sage

          sage: m = SymmetricFunctions(QQ).monomial()
          sage: zee = sage.combinat.sf.sfa.zee
          sage: h = m.dual_basis(scalar=zee)
          sage: a = h([2,1])
          sage: a.scalar(a)
          2

      Python

          >>> from sage.all import *
          >>> m = SymmetricFunctions(QQ).monomial()
          >>> zee = sage.combinat.sf.sfa.zee
          >>> h = m.dual_basis(scalar=zee)
          >>> a = h([Integer(2),Integer(1)])
          >>> a.scalar(a)
          2

    scalar_hl(x)

      Return the Hall-Littlewood scalar product of `self` and `x`.

      INPUT:

      - `x` – element of the same dual basis as `self`

      OUTPUT: the Hall-Littlewood scalar product between `x` and `self`

      EXAMPLES:

      Sage

          sage: m = SymmetricFunctions(QQ).monomial()
          sage: zee = sage.combinat.sf.sfa.zee
          sage: h = m.dual_basis(scalar=zee)
          sage: a = h([2,1])
          sage: a.scalar_hl(a)
          (-t - 2)/(t^4 - 2*t^3 + 2*t - 1)

      Python

          >>> from sage.all import *
          >>> m = SymmetricFunctions(QQ).monomial()
          >>> zee = sage.combinat.sf.sfa.zee
          >>> h = m.dual_basis(scalar=zee)
          >>> a = h([Integer(2),Integer(1)])
          >>> a.scalar_hl(a)
          (-t - 2)/(t^4 - 2*t^3 + 2*t - 1)

  basis_name()

    Return the name of the basis of `self`.

    This is used for output and, for the classical bases of symmetric functions, to connect this basis with Symmetrica.

    EXAMPLES:

    Sage

        sage: Sym = SymmetricFunctions(QQ)
        sage: f = Sym.f()
        sage: f.basis_name()
        'forgotten'

    Python

        >>> from sage.all import *
        >>> Sym = SymmetricFunctions(QQ)
        >>> f = Sym.f()
        >>> f.basis_name()
        'forgotten'

  construction()

    Return a pair `(F, R)`, where `F` is a `SymmetricFunctionsFunctor` and \(R\) is a ring, such that `F(R)` returns `self`.

    EXAMPLES:

    Sage

        sage: w = SymmetricFunctions(ZZ).witt()
        sage: w.dual_basis().construction()
        (SymmetricFunctionsFunctor[dual Witt], Integer Ring)

    Python

        >>> from sage.all import *
        >>> w = SymmetricFunctions(ZZ).witt()
        >>> w.dual_basis().construction()
        (SymmetricFunctionsFunctor[dual Witt], Integer Ring)

  product(left, right)

    Return product of `left` and `right`.

    Multiplication is done by performing the multiplication in the dual basis of `self` and then converting back to `self`.

    INPUT:

    - `left`, `right` – elements of `self`

    OUTPUT: the product of `left` and `right` in the basis `self`

    EXAMPLES:

    Sage

        sage: m = SymmetricFunctions(QQ).monomial()
        sage: zee = sage.combinat.sf.sfa.zee
        sage: h = m.dual_basis(scalar=zee)
        sage: a = h([2])
        sage: b = a*a; b # indirect doctest
        d_m[2, 2]
        sage: b.dual()
        6*m[1, 1, 1, 1] + 4*m[2, 1, 1] + 3*m[2, 2] + 2*m[3, 1] + m[4]

    Python

        >>> from sage.all import *
        >>> m = SymmetricFunctions(QQ).monomial()
        >>> zee = sage.combinat.sf.sfa.zee
        >>> h = m.dual_basis(scalar=zee)
        >>> a = h([Integer(2)])
        >>> b = a*a; b # indirect doctest
        d_m[2, 2]
        >>> b.dual()
        6*m[1, 1, 1, 1] + 4*m[2, 1, 1] + 3*m[2, 2] + 2*m[3, 1] + m[4]

  transition_matrix(basis, n)

    Return the transition matrix between the \(n\)-th homogeneous components of `self` and `basis`.

    INPUT:

    - `basis` – a target basis of the ring of symmetric functions

    - `n` – nonnegative integer

    OUTPUT:

    - A transition matrix from `self` to `basis` for the elements of degree `n`. The indexing order of the rows and columns is the order of `Partitions(n)`.

    EXAMPLES:

    Sage

        sage: Sym = SymmetricFunctions(QQ)
        sage: s = Sym.schur()
        sage: e = Sym.elementary()
        sage: f = e.dual_basis()
        sage: f.transition_matrix(s, 5)
        [ 1 -1  0  1  0 -1  1]
        [-2  1  1 -1 -1  1  0]
        [-2  2 -1 -1  1  0  0]
        [ 3 -1 -1  1  0  0  0]
        [ 3 -2  1  0  0  0  0]
        [-4  1  0  0  0  0  0]
        [ 1  0  0  0  0  0  0]
        sage: Partitions(5).list()
        [[5], [4, 1], [3, 2], [3, 1, 1], [2, 2, 1], [2, 1, 1, 1], [1, 1, 1, 1, 1]]
        sage: s(f[2,2,1])
        s[3, 2] - 2*s[4, 1] + 3*s[5]
        sage: e.transition_matrix(s, 5).inverse().transpose()
        [ 1 -1  0  1  0 -1  1]
        [-2  1  1 -1 -1  1  0]
        [-2  2 -1 -1  1  0  0]
        [ 3 -1 -1  1  0  0  0]
        [ 3 -2  1  0  0  0  0]
        [-4  1  0  0  0  0  0]
        [ 1  0  0  0  0  0  0]

    Python

        >>> from sage.all import *
        >>> Sym = SymmetricFunctions(QQ)
        >>> s = Sym.schur()
        >>> e = Sym.elementary()
        >>> f = e.dual_basis()
        >>> f.transition_matrix(s, Integer(5))
        [ 1 -1  0  1  0 -1  1]
        [-2  1  1 -1 -1  1  0]
        [-2  2 -1 -1  1  0  0]
        [ 3 -1 -1  1  0  0  0]
        [ 3 -2  1  0  0  0  0]
        [-4  1  0  0  0  0  0]
        [ 1  0  0  0  0  0  0]
        >>> Partitions(Integer(5)).list()
        [[5], [4, 1], [3, 2], [3, 1, 1], [2, 2, 1], [2, 1, 1, 1], [1, 1, 1, 1, 1]]
        >>> s(f[Integer(2),Integer(2),Integer(1)])
        s[3, 2] - 2*s[4, 1] + 3*s[5]
        >>> e.transition_matrix(s, Integer(5)).inverse().transpose()
        [ 1 -1  0  1  0 -1  1]
        [-2  1  1 -1 -1  1  0]
        [-2  2 -1 -1  1  0  0]
        [ 3 -1 -1  1  0  0  0]
        [ 3 -2  1  0  0  0  0]
        [-4  1  0  0  0  0  0]
        [ 1  0  0  0  0  0  0]