Kostka-Foulkes Polynomials

Based on the algorithms in John Stembridge’s SF package for Maple which can be found at http://www.math.lsa.umich.edu/~jrs/maple.html .

sage.combinat.sf.kfpoly.KostkaFoulkesPolynomial(mu, nu, t=None)[source]

Return the Kostka-Foulkes polynomial \(K_{\mu, \nu}(t)\).

INPUT:

  • mu, nu – partitions

  • t – an optional parameter (default: None)

OUTPUT:

  • the Koskta-Foulkes polynomial indexed by partitions mu and nu and evaluated at the parameter t. If t is None the resulting polynomial is in the polynomial ring \(\ZZ['t']\).

EXAMPLES:

sage: KostkaFoulkesPolynomial([2,2],[2,2])
1
sage: KostkaFoulkesPolynomial([2,2],[4])
0
sage: KostkaFoulkesPolynomial([2,2],[1,1,1,1])
t^4 + t^2
sage: KostkaFoulkesPolynomial([2,2],[2,1,1])
t
sage: q = PolynomialRing(QQ,'q').gen()
sage: KostkaFoulkesPolynomial([2,2],[2,1,1],q)
q

>>> from sage.all import *
>>> KostkaFoulkesPolynomial([Integer(2),Integer(2)],[Integer(2),Integer(2)])
1
>>> KostkaFoulkesPolynomial([Integer(2),Integer(2)],[Integer(4)])
0
>>> KostkaFoulkesPolynomial([Integer(2),Integer(2)],[Integer(1),Integer(1),Integer(1),Integer(1)])
t^4 + t^2
>>> KostkaFoulkesPolynomial([Integer(2),Integer(2)],[Integer(2),Integer(1),Integer(1)])
t
>>> q = PolynomialRing(QQ,'q').gen()
>>> KostkaFoulkesPolynomial([Integer(2),Integer(2)],[Integer(2),Integer(1),Integer(1)],q)
q
sage.combinat.sf.kfpoly.compat(n, mu, nu)[source]

Generate all possible partitions of \(n\) that can precede \(\mu, \nu\) in a rigging sequence.

INPUT:

  • n – positive integer

  • mu, nu – partitions

OUTPUT: list of partitions

EXAMPLES:

sage: from sage.combinat.sf.kfpoly import *
sage: compat(4, [1], [2,1])
[[1, 1, 1, 1], [2, 1, 1], [2, 2], [3, 1], [4]]
sage: compat(3, [1], [2,1])
[[1, 1, 1], [2, 1], [3]]
sage: compat(2, [1], [])
[[2]]
sage: compat(3, [1], [])
[[2, 1], [3]]
sage: compat(3, [2], [1])
[[3]]
sage: compat(4, [1,1], [])
[[2, 2], [3, 1], [4]]
sage: compat(4, [2], [])
[[4]]

>>> from sage.all import *
>>> from sage.combinat.sf.kfpoly import *
>>> compat(Integer(4), [Integer(1)], [Integer(2),Integer(1)])
[[1, 1, 1, 1], [2, 1, 1], [2, 2], [3, 1], [4]]
>>> compat(Integer(3), [Integer(1)], [Integer(2),Integer(1)])
[[1, 1, 1], [2, 1], [3]]
>>> compat(Integer(2), [Integer(1)], [])
[[2]]
>>> compat(Integer(3), [Integer(1)], [])
[[2, 1], [3]]
>>> compat(Integer(3), [Integer(2)], [Integer(1)])
[[3]]
>>> compat(Integer(4), [Integer(1),Integer(1)], [])
[[2, 2], [3, 1], [4]]
>>> compat(Integer(4), [Integer(2)], [])
[[4]]
sage.combinat.sf.kfpoly.dom(mup, snu)[source]

Return True if sum(mu[:i+1]) >= snu[i] for all 0 <= i < len(snu); otherwise, it returns False.

INPUT:

  • mup – a partition conjugate to mu

  • snu – a sequence of positive integers

OUTPUT: boolean

EXAMPLES:

sage: from sage.combinat.sf.kfpoly import *
sage: dom([3,2,1],[2,4,5])
True
sage: dom([3,2,1],[2,4,7])
False
sage: dom([3,2,1],[2,6,5])
False
sage: dom([3,2,1],[4,4,4])
False

>>> from sage.all import *
>>> from sage.combinat.sf.kfpoly import *
>>> dom([Integer(3),Integer(2),Integer(1)],[Integer(2),Integer(4),Integer(5)])
True
>>> dom([Integer(3),Integer(2),Integer(1)],[Integer(2),Integer(4),Integer(7)])
False
>>> dom([Integer(3),Integer(2),Integer(1)],[Integer(2),Integer(6),Integer(5)])
False
>>> dom([Integer(3),Integer(2),Integer(1)],[Integer(4),Integer(4),Integer(4)])
False
sage.combinat.sf.kfpoly.kfpoly(mu, nu, t=None)[source]

Return the Kostka-Foulkes polynomial \(K_{\mu, \nu}(t)\) by generating all rigging sequences for the shape \(\mu\), and then selecting those of content \(\nu\).

INPUT:

  • mu, nu – partitions

  • t – an optional parameter (default: None)

OUTPUT:

  • the Koskta-Foulkes polynomial indexed by partitions mu and nu and evaluated at the parameter t. If t is None the resulting polynomial is in the polynomial ring \(\ZZ['t']\).

EXAMPLES:

sage: from sage.combinat.sf.kfpoly import kfpoly
sage: kfpoly([2,2], [2,1,1])
t
sage: kfpoly([4], [2,1,1])
t^3
sage: kfpoly([4], [2,2])
t^2
sage: kfpoly([1,1,1,1], [2,2])
0

>>> from sage.all import *
>>> from sage.combinat.sf.kfpoly import kfpoly
>>> kfpoly([Integer(2),Integer(2)], [Integer(2),Integer(1),Integer(1)])
t
>>> kfpoly([Integer(4)], [Integer(2),Integer(1),Integer(1)])
t^3
>>> kfpoly([Integer(4)], [Integer(2),Integer(2)])
t^2
>>> kfpoly([Integer(1),Integer(1),Integer(1),Integer(1)], [Integer(2),Integer(2)])
0
sage.combinat.sf.kfpoly.riggings(part)[source]

Generate all possible rigging sequences for a fixed partition part.

INPUT:

  • part – a partition

OUTPUT: list of riggings associated to the partition part

EXAMPLES:

sage: from sage.combinat.sf.kfpoly import *
sage: riggings([3])
[[[1, 1, 1]], [[2, 1]], [[3]]]
sage: riggings([2,1])
[[[2, 1], [1]], [[3], [1]]]
sage: riggings([1,1,1])
[[[3], [2], [1]]]
sage: riggings([2,2])
[[[2, 2], [1, 1]], [[3, 1], [1, 1]], [[4], [1, 1]], [[4], [2]]]
sage: riggings([2,2,2])
[[[3, 3], [2, 2], [1, 1]],
 [[4, 2], [2, 2], [1, 1]],
 [[5, 1], [2, 2], [1, 1]],
 [[6], [2, 2], [1, 1]],
 [[5, 1], [3, 1], [1, 1]],
 [[6], [3, 1], [1, 1]],
 [[6], [4], [2]]]

>>> from sage.all import *
>>> from sage.combinat.sf.kfpoly import *
>>> riggings([Integer(3)])
[[[1, 1, 1]], [[2, 1]], [[3]]]
>>> riggings([Integer(2),Integer(1)])
[[[2, 1], [1]], [[3], [1]]]
>>> riggings([Integer(1),Integer(1),Integer(1)])
[[[3], [2], [1]]]
>>> riggings([Integer(2),Integer(2)])
[[[2, 2], [1, 1]], [[3, 1], [1, 1]], [[4], [1, 1]], [[4], [2]]]
>>> riggings([Integer(2),Integer(2),Integer(2)])
[[[3, 3], [2, 2], [1, 1]],
 [[4, 2], [2, 2], [1, 1]],
 [[5, 1], [2, 2], [1, 1]],
 [[6], [2, 2], [1, 1]],
 [[5, 1], [3, 1], [1, 1]],
 [[6], [3, 1], [1, 1]],
 [[6], [4], [2]]]
sage.combinat.sf.kfpoly.schur_to_hl(mu, t=None)[source]

Return a dictionary corresponding to \(s_\mu\) in Hall-Littlewood \(P\) basis.

INPUT:

  • mu – a partition

  • t – an optional parameter (default: the generator from \(\ZZ['t']\) )

OUTPUT:

  • a dictionary with the coefficients \(K_{\mu\nu}(t)\) for \(\nu\) smaller in dominance order than \(\mu\)

EXAMPLES:

sage: from sage.combinat.sf.kfpoly import *
sage: schur_to_hl([1,1,1])
{[1, 1, 1]: 1}
sage: a = schur_to_hl([2,1])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1], t^2 + t)
([2, 1], 1)
sage: a = schur_to_hl([3])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1], t^3)
([2, 1], t)
([3], 1)
sage: a = schur_to_hl([4])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^6)
([2, 1, 1], t^3)
([2, 2], t^2)
([3, 1], t)
([4], 1)
sage: a = schur_to_hl([3,1])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^5 + t^4 + t^3)
([2, 1, 1], t^2 + t)
([2, 2], t)
([3, 1], 1)
sage: a = schur_to_hl([2,2])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^4 + t^2)
([2, 1, 1], t)
([2, 2], 1)
sage: a = schur_to_hl([2,1,1])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^3 + t^2 + t)
([2, 1, 1], 1)
sage: a = schur_to_hl([1,1,1,1])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], 1)
sage: a = schur_to_hl([2,2,2])
sage: for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1, 1, 1], t^9 + t^7 + t^6 + t^5 + t^3)
([2, 1, 1, 1, 1], t^4 + t^2)
([2, 2, 1, 1], t)
([2, 2, 2], 1)

>>> from sage.all import *
>>> from sage.combinat.sf.kfpoly import *
>>> schur_to_hl([Integer(1),Integer(1),Integer(1)])
{[1, 1, 1]: 1}
>>> a = schur_to_hl([Integer(2),Integer(1)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1], t^2 + t)
([2, 1], 1)
>>> a = schur_to_hl([Integer(3)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1], t^3)
([2, 1], t)
([3], 1)
>>> a = schur_to_hl([Integer(4)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^6)
([2, 1, 1], t^3)
([2, 2], t^2)
([3, 1], t)
([4], 1)
>>> a = schur_to_hl([Integer(3),Integer(1)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^5 + t^4 + t^3)
([2, 1, 1], t^2 + t)
([2, 2], t)
([3, 1], 1)
>>> a = schur_to_hl([Integer(2),Integer(2)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^4 + t^2)
([2, 1, 1], t)
([2, 2], 1)
>>> a = schur_to_hl([Integer(2),Integer(1),Integer(1)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], t^3 + t^2 + t)
([2, 1, 1], 1)
>>> a = schur_to_hl([Integer(1),Integer(1),Integer(1),Integer(1)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1], 1)
>>> a = schur_to_hl([Integer(2),Integer(2),Integer(2)])
>>> for mc in sorted(a.items()): print(mc)
([1, 1, 1, 1, 1, 1], t^9 + t^7 + t^6 + t^5 + t^3)
([2, 1, 1, 1, 1], t^4 + t^2)
([2, 2, 1, 1], t)
([2, 2, 2], 1)
sage.combinat.sf.kfpoly.weight(rg, t=None)[source]

Return the weight of a rigging.

INPUT:

  • rg – a rigging, a list of partitions

  • t – an optional parameter, (default: the generator from \(\ZZ['t']\))

OUTPUT: a polynomial in the parameter \(t\)

EXAMPLES:

sage: from sage.combinat.sf.kfpoly import weight
sage: weight([[2,1], [1]])
1
sage: weight([[3], [1]])
t^2 + t
sage: weight([[2,1], [3]])
t^4
sage: weight([[2, 2], [1, 1]])
1
sage: weight([[3, 1], [1, 1]])
t
sage: weight([[4], [1, 1]], 2)
16
sage: weight([[4], [2]], t=2)
4

>>> from sage.all import *
>>> from sage.combinat.sf.kfpoly import weight
>>> weight([[Integer(2),Integer(1)], [Integer(1)]])
1
>>> weight([[Integer(3)], [Integer(1)]])
t^2 + t
>>> weight([[Integer(2),Integer(1)], [Integer(3)]])
t^4
>>> weight([[Integer(2), Integer(2)], [Integer(1), Integer(1)]])
1
>>> weight([[Integer(3), Integer(1)], [Integer(1), Integer(1)]])
t
>>> weight([[Integer(4)], [Integer(1), Integer(1)]], Integer(2))
16
>>> weight([[Integer(4)], [Integer(2)]], t=Integer(2))
4