### Navigation

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

# 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)

  Returns 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

`sage.combinat.sf.kfpoly.``compat`(n, mu, nu)

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

  INPUT:

  - `n` – a positive integer
  - `mu`, `nu` – partitions

  OUTPUT:

  - a 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]]

`sage.combinat.sf.kfpoly.``dom`(mu, snu)

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

  INPUT:

  - `mu` – a partition
  - `snu` – a sequence of positive integers

  OUTPUT:

  - a boolean value

  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

`sage.combinat.sf.kfpoly.``kfpoly`(mu, nu, t=None)

  Returns 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 \(\mathbb{Z}['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

`sage.combinat.sf.kfpoly.``q_bin`(a, b, t=None)

  Returns the \(t\)-binomial coefficient \([a+b,b]_t\).

  INPUT:

  - `a`, `b` – two nonnegative integers

  By definition \([a+b,b]_t = (1-t)(1-t^2) \cdots (1-t^{a+b}) / ((1-t) \cdots (1-t^b) (1-t) \cdots (1-t^a))\).

  EXAMPLES:

      sage: from sage.combinat.sf.kfpoly import q_bin
      sage: t = PolynomialRing(ZZ, 't').gen()
      sage: q_bin(4,2, t)
      doctest:...: DeprecationWarning: please use sage.combinat.q_analogues.q_binomial instead
      See http://trac.sagemath.org/14496 for details.
      t^8 + t^7 + 2*t^6 + 2*t^5 + 3*t^4 + 2*t^3 + 2*t^2 + t + 1
      sage: q_bin(4,3, t)
      t^12 + t^11 + 2*t^10 + 3*t^9 + 4*t^8 + 4*t^7 + 5*t^6 + 4*t^5 + 4*t^4 + 3*t^3 + 2*t^2 + t + 1

`sage.combinat.sf.kfpoly.``riggings`(part)

  Generate all possible rigging sequences for a fixed sage.combinat.partition.

  INPUT:

  - `part` – a partition

  OUTPUT:

  - returns a 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]]]

`sage.combinat.sf.kfpoly.``schur_to_hl`(mu, t=None)

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

  INPUT:

  - `mu` – a partition
  - `t` – an optional parameter (default : the generator from \(\mathbb{Z}['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 m,c in sorted(a.iteritems()): print m, c
      [1, 1, 1] t^2 + t
      [2, 1] 1
      sage: a = schur_to_hl([3])
      sage: for m,c in sorted(a.iteritems()): print m, c
      [1, 1, 1] t^3
      [2, 1] t
      [3] 1
      sage: a = schur_to_hl([4])
      sage: for m,c in sorted(a.iteritems()): print m, c
      [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 m,c in sorted(a.iteritems()): print m, c
      [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 m,c in sorted(a.iteritems()): print m, c
      [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 m,c in sorted(a.iteritems()): print m, c
      [1, 1, 1, 1] t^3 + t^2 + t
      [2, 1, 1] 1
      sage: a = schur_to_hl([1,1,1,1])
      sage: for m,c in sorted(a.iteritems()): print m, c
      [1, 1, 1, 1] 1
      sage: a = schur_to_hl([2,2,2])
      sage: for m,c in sorted(a.iteritems()): print m, c
      [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)

  Returns the weight of a rigging.

  INPUT:

  - `rg` – a rigging, a list of partitions
  - `t` – an optional parameter, (default : uses 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

### Navigation

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