Symplectic symmetric functions - Combinatorics

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

# Symplectic symmetric functions

AUTHORS:

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

class sage.combinat.sf.symplectic.SymmetricFunctionAlgebra_symplectic(Sym)

  Bases: `SymmetricFunctionAlgebra_generic`

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

  The symplectic basis \(\{ sp_{\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 V} c^{\lambda}_{\mu\nu} \right) sp_{\mu}\]

  where \(V\) is the set of all partitions with even-height columns 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]

  Vyjayanthi Chari and Michael Kleber. Symmetric functions and representations of quantum affine algebras. arXiv math/0011161v1

  [KoikeTerada1987]

  K. Koike, I. Terada, Young-diagrammatic methods for the representation theory of the classical groups of type Bn, Cn, Dn. J. Algebra 107 (1987), no. 2, 466-511.

  [ShimozonoZabrocki2006]

  Mark Shimozono and Mike Zabrocki. Deformed universal characters for classical and affine algebras. Journal of Algebra, 299 (2006). arXiv math/0404288.

  EXAMPLES:

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

  Sage

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

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

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

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

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

  Python

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

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

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

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

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

  Some examples of conversions the other way:

  Sage

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

  [Python]

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

  Some multiplication:

  Sage

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

  Python

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

  Examples of the Hopf algebra structure:

  Sage

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

  [Python]

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