Orthogonal symmetric functions - Combinatorics

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

# Orthogonal symmetric functions

AUTHORS:

- Travis Scrimshaw (2013-11-10): Initial version

class sage.combinat.sf.orthogonal.SymmetricFunctionAlgebra_orthogonal(Sym)

  Bases: `SymmetricFunctionAlgebra_generic`

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

  The orthogonal basis \(\{ o_{\lambda} \}\) where \(\lambda\) is taken over all partitions is defined by the following change of basis with the Schur functions:

  \[s_{\lambda} = \sum_{\mu} \left( \sum_{\nu \in H} c^{\lambda}_{\mu\nu} \right) o_{\mu}\]

  where \(H\) is the set of all partitions with even-width rows and \(c^{\lambda}_{\mu\nu}\) is the usual Littlewood-Richardson (LR) coefficients. By the properties of LR coefficients, this can be shown to be a upper unitriangular change of basis.

  Note

  This is only a filtered basis, not a \(\ZZ\)-graded basis. However this does respect the induced \((\ZZ/2\ZZ)\)-grading.

  INPUT:

  - `Sym` – an instance of the ring of the symmetric functions

  REFERENCES:

  - [ChariKleber2000]

  - [KoikeTerada1987]

  - [ShimozonoZabrocki2006]

  EXAMPLES:

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

  Sage

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

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

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

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

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

  Python

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

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

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

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

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

  Some examples of conversions the other way:

  Sage

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

  [Python]

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

  Some multiplication:

  Sage

      sage: o([2]) * o([1,1])
      o[1, 1] + o[2] + o[2, 1, 1] + o[3, 1]
      sage: o([2,1,1]) * o([2])
      o[1, 1] + o[1, 1, 1, 1] + 2*o[2, 1, 1] + o[2, 2] + o[2, 2, 1, 1]
       + o[3, 1] + o[3, 1, 1, 1] + o[3, 2, 1] + o[4, 1, 1]
      sage: o([1,1]) * o([2,1])
      o[1] + o[1, 1, 1] + 2*o[2, 1] + o[2, 1, 1, 1] + o[2, 2, 1]
       + o[3] + o[3, 1, 1] + o[3, 2]

  Python

      >>> from sage.all import *
      >>> o([Integer(2)]) * o([Integer(1),Integer(1)])
      o[1, 1] + o[2] + o[2, 1, 1] + o[3, 1]
      >>> o([Integer(2),Integer(1),Integer(1)]) * o([Integer(2)])
      o[1, 1] + o[1, 1, 1, 1] + 2*o[2, 1, 1] + o[2, 2] + o[2, 2, 1, 1]
       + o[3, 1] + o[3, 1, 1, 1] + o[3, 2, 1] + o[4, 1, 1]
      >>> o([Integer(1),Integer(1)]) * o([Integer(2),Integer(1)])
      o[1] + o[1, 1, 1] + 2*o[2, 1] + o[2, 1, 1, 1] + o[2, 2, 1]
       + o[3] + o[3, 1, 1] + o[3, 2]

  Examples of the Hopf algebra structure:

  Sage

      sage: o([1]).antipode()
      -o[1]
      sage: o([2]).antipode()
      -o[] + o[1, 1]
      sage: o([1]).coproduct()
      o[] # o[1] + o[1] # o[]
      sage: o([2]).coproduct()
      o[] # o[] + o[] # o[2] + o[1] # o[1] + o[2] # o[]
      sage: o([1]).counit()
      0
      sage: o.one().counit()
      1

  [Python]

      >>> from sage.all import *
      >>> o([Integer(1)]).antipode()
      -o[1]
      >>> o([Integer(2)]).antipode()
      -o[] + o[1, 1]
      >>> o([Integer(1)]).coproduct()
      o[] # o[1] + o[1] # o[]
      >>> o([Integer(2)]).coproduct()
      o[] # o[] + o[] # o[2] + o[1] # o[1] + o[2] # o[]
      >>> o([Integer(1)]).counit()
      0
      >>> o.one().counit()
      1