Macdonald Polynomials

class sage.combinat.sf.macdonald.MacdonaldPolynomial_generic(A, x)
nabla()

Returns the value of the nabla operator applied to self. The eigenvectors of the nabla operator are the Macdonald polynomials in the Ht basis.

EXAMPLES:

sage: from sage.combinat.sf.macdonald import *
sage: P = MacdonaldPolynomialsP(QQ)
sage: P([1,1]).nabla()
((q^2*t+q*t^2-2*t)/(q*t-1))*McdP[1, 1] + McdP[2]
omega_qt()

Returns the image of self under the \omega_{qt} automorphism.

EXAMPLES:

sage: H = MacdonaldPolynomialsH(QQ)
sage: H([1,1]).omega_qt()
((2*q^2-2*q*t-2*q+2*t)/(t^3-t^2-t+1))*McdH[1, 1] + ((q-1)/(t-1))*McdH[2]
scalar_qt(x)

Returns the qt-Hall scalar product of self and x by converting both to the power-sum basis.

EXAMPLES:

sage: H = MacdonaldPolynomialsH(QQ)
sage: H([1]).scalar_qt(H([1]))
(-q + 1)/(-t + 1)
class sage.combinat.sf.macdonald.MacdonaldPolynomial_h(A, x)
class sage.combinat.sf.macdonald.MacdonaldPolynomial_ht(A, x)
nabla()

Returns the value of the nabla operator applied to self. The eigenvectors of the nabla operator are the Macdonald polynomials in the Ht basis.

EXAMPLES:

sage: Ht = MacdonaldPolynomialsHt(QQ)
sage: t = Ht.t; q = Ht.q;
sage: a = sum(Ht(p) for p in Partitions(3))
sage: a.nabla() == t^3*Ht([1,1,1])+q*t*Ht([2,1]) + q^3*Ht([3])
True
class sage.combinat.sf.macdonald.MacdonaldPolynomial_j(A, x)
scalar_qt(x)

Returns the qt-Hall scalar product of self and x. If x is in the Macdonald J basis, then specialized code is used; otherwise, both are converted to the power-sums and the scalar product is carried out there.

EXAMPLES:

sage: J = MacdonaldPolynomialsJ(QQ)
sage: J([1,1]).scalar_qt(J([1,1]))
q^2*t^4 - q^2*t^3 - q*t^4 - q^2*t^2 + q^2*t + 2*q*t^2 + t^3 - t^2 - q - t + 1
sage: J([1,1]).scalar_qt(J([2]))
0
sage: J([2]).scalar_qt(J([2]))
q^4*t^2 - q^4*t - q^3*t^2 - q^2*t^2 + q^3 + 2*q^2*t + q*t^2 - q^2 - q - t + 1
class sage.combinat.sf.macdonald.MacdonaldPolynomial_p(A, x)
scalar_qt(x)

Returns the qt-Hall scalar product of self and x. If x is in the Macdonald P or Q basis, then specialized code is used; otherwise, both are converted to the power-sums and the scalar product is carried out there.

EXAMPLES:

sage: Q = MacdonaldPolynomialsQ(QQ)
sage: P = MacdonaldPolynomialsP(QQ)
sage: a = P([2])
sage: b = Q([2])
sage: a.scalar_qt(a)
(q^3 - q^2 - q + 1)/(q*t^2 - q*t - t + 1)
sage: a.scalar_qt(b)
1
class sage.combinat.sf.macdonald.MacdonaldPolynomial_q(A, x)
scalar_qt(x)

Returns the qt-Hall scalar product of self and x. If x is in the Macdonald P basis, then specialized code is used; otherwise, both are converted to the power-sums and the scalar product is carried out there.

EXAMPLES:

sage: Q = MacdonaldPolynomialsQ(QQ)
sage: H = MacdonaldPolynomialsH(QQ)
sage: a = Q([2])
sage: a.scalar_qt(a)
(-q*t^2 + q*t + t - 1)/(-q^3 + q^2 + q - 1)
sage: a.scalar_qt(H([1,1]))
t
class sage.combinat.sf.macdonald.MacdonaldPolynomial_s(A, x)
_creation_by_determinant(k)

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: a = S(1)
sage: a._creation_by_determinant(1)
(-q+1)*McdS[1]
sage: a._creation_by_determinant(2)
(q^2*t-q*t-q+1)*McdS[1, 1] + (q^2-q*t-q+t)*McdS[2]
_creation_by_determinant_helper(k, part)

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: a = S([2,1])
sage: a._creation_by_determinant_helper(2,[1])
(q^3*t-q^2*t-q+1)*McdS[2, 1] + (q^3-q^2*t-q+t)*McdS[3]
_omega_qt_in_schurs()

Returns the image of self under the omega_qt automorphism in the Schur basis.

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: a = S([2,1]) + S([1,1,1])
sage: a._omega_qt_in_schurs()
s[2, 1] + s[3]
creation(k)

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: a = S(1)
sage: a.creation(1)
(-q+1)*McdS[1]
sage: a.creation(2)
(q^2*t-q*t-q+1)*McdS[1, 1] + (q^2-q*t-q+t)*McdS[2]
omega_qt()

Returns the image of self under the Frobenius / omega automorphism.

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: S([1,1]).omega_qt()
(t/(t^3-t^2-t+1))*McdS[1, 1] + ((-1)/(-t^3+t^2+t-1))*McdS[2]
sage.combinat.sf.macdonald.MacdonaldPolynomialsH(R, q=None, t=None)

Returns the Macdonald polynomials on the H basis. When the H basis is expanded on the Schur basis, the coefficients are the qt-Kostka numbers.

EXAMPLES:

sage: H = MacdonaldPolynomialsH(QQ)
sage: s = SFASchur(H.base_ring())
sage: s(H([2]))
q*s[1, 1] + s[2]
sage: s(H([1,1]))
s[1, 1] + t*s[2]
sage.combinat.sf.macdonald.MacdonaldPolynomialsHt(R, q=None, t=None)

Returns the Macdonald polynomials on the Ht basis. The elements of the Ht basis are eigenvectors of the nabla operator. When expanded on the Schur basis, the coefficients are the modified qt-Kostka numbers.

EXAMPLES:

sage: Ht = MacdonaldPolynomialsHt(QQ)
sage: [Ht(p).nabla() for p in Partitions(3)]
[q^3*McdHt[3], q*t*McdHt[2, 1], t^3*McdHt[1, 1, 1]]
sage: s = SFASchur(Ht.base_ring())
sage: from sage.combinat.sf.macdonald import qt_kostka
sage: q,t = Ht.base_ring().gens()
sage: s(Ht([2,1]))
q*t*s[1, 1, 1] + (q+t)*s[2, 1] + s[3]
sage: qt_kostka([1,1,1],[2,1]).subs(t=1/t)*t^Partition([2,1]).weighted_size()
q*t
sage: qt_kostka([2,1],[2,1]).subs(t=1/t)*t^Partition([2,1]).weighted_size()
q + t
sage: qt_kostka([3],[2,1]).subs(t=1/t)*t^Partition([2,1]).weighted_size()
1
sage.combinat.sf.macdonald.MacdonaldPolynomialsJ(R, q=None, t=None)

Returns the Macdonald polynomials on the J basis also known as the integral form of the Macdonald polynomials. These are scalar multiples of both the P and Q bases. When expressed in the P or Q basis, the scaling coefficients are polynomials in q and t rather than rational functions.

EXAMPLES:

sage: J = MacdonaldPolynomialsJ(QQ); J
Macdonald polynomials in the J basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field
sage: P = MacdonaldPolynomialsP(QQ)
sage: Q = MacdonaldPolynomialsQ(QQ)
sage: P(J([2]))
(q*t^2-q*t-t+1)*McdP[2]
sage: P(J([1,1]))
(t^3-t^2-t+1)*McdP[1, 1]
sage: Q(J([2]))
(q^3-q^2-q+1)*McdQ[2]
sage: Q(J([1,1]))
(q^2*t-q*t-q+1)*McdQ[1, 1]
sage.combinat.sf.macdonald.MacdonaldPolynomialsP(R, q=None, t=None)

Returns the Macdonald polynomials on the P basis. These are upper triangularly related to the monomial symmetric functions and are orthogonal with respect to the qt-Hall scalar product.

EXAMPLES:

sage: P = MacdonaldPolynomialsP(QQ); P
Macdonald polynomials in the P basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field
sage: m = SFAMonomial(P.base_ring())
sage: P.transition_matrix(m,2)
[                          1 (q*t - q + t - 1)/(q*t - 1)]
[                          0                           1]
sage: P([1,1]).scalar_qt(P([2]))
0
sage: P([2]).scalar_qt(P([2]))
(q^3 - q^2 - q + 1)/(q*t^2 - q*t - t + 1)
sage: P([1,1]).scalar_qt(P([1,1]))
(q^2*t - q*t - q + 1)/(t^3 - t^2 - t + 1)

When q = 0, the Macdonald polynomials on the P basis are the same as the Hall-Littlewood polynomials on the P basis.

sage: P = MacdonaldPolynomialsP(QQ,q=0)
sage: P([2])^2
(t+1)*McdP[2, 2] + (-t+1)*McdP[3, 1] + McdP[4]
sage: HLP = HallLittlewoodP(QQ)
sage: HLP([2])^2
(t+1)*P[2, 2] + (-t+1)*P[3, 1] + P[4]
sage.combinat.sf.macdonald.MacdonaldPolynomialsQ(R, q=None, t=None)

Returns the Macdonald polynomials on the Q basis. These are dual to the Macdonald polynomials on the P basis with respect to the qt-Hall scalar product.

EXAMPLES:

sage: Q = MacdonaldPolynomialsQ(QQ); Q
Macdonald polynomials in the Q basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field
sage: P = MacdonaldPolynomialsP(QQ)
sage: Q([2]).scalar_qt(P([2]))
1
sage: Q([2]).scalar_qt(P([1,1]))
0
sage: Q([1,1]).scalar_qt(P([2]))
0
sage: Q([1,1]).scalar_qt(P([1,1]))
1
sage: Q(P([2]))
((q^3-q^2-q+1)/(q*t^2-q*t-t+1))*McdQ[2]
sage: Q(P([1,1]))
((q^2*t-q*t-q+1)/(t^3-t^2-t+1))*McdQ[1, 1]
sage.combinat.sf.macdonald.MacdonaldPolynomialsS(R, q=None, t=None)

Returns the modified Schur functions defined by the plethystic substitution S_{\mu} = s_{\mu}[X(1-t)]. When the Macdonald polynomials in the J basis are expressed in terms of the modified Schur functions, the coefficients are qt-Kostka numbers.

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: J = MacdonaldPolynomialsJ(QQ)
sage: S(J([2]))
q*McdS[1, 1] + ((-1)/(-1))*McdS[2]
sage: S(J([1,1]))
McdS[1, 1] + t*McdS[2]
sage: from sage.combinat.sf.macdonald import qt_kostka
sage: qt_kostka([2],[1,1])
t
sage: qt_kostka([1,1],[2])
q
class sage.combinat.sf.macdonald.MacdonaldPolynomials_generic(R, q=None, t=None)
__init__(R, q=None, t=None)

EXAMPLES:

sage: MacdonaldPolynomialsP(QQ)
Macdonald polynomials in the P basis over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field
sage: MacdonaldPolynomialsP(QQ,t=2)
Macdonald polynomials in the P basis with t=2 over Fraction Field of Univariate Polynomial Ring in q over Rational Field
sage: MacdonaldPolynomialsP(QQ,q=2)
Macdonald polynomials in the P basis with q=2 over Fraction Field of Univariate Polynomial Ring in t over Rational Field
sage: MacdonaldPolynomialsP(QQ,q=2,t=2)
Macdonald polynomials in the P basis with q=2 and t=2 over Rational Field
class sage.combinat.sf.macdonald.MacdonaldPolynomials_h(R, q=None, t=None)
__init__(R, q=None, t=None)

TESTS:

sage: H = MacdonaldPolynomialsH(QQ)
sage: H == loads(dumps(H))
True
_coerce_start(x)

Coerce things into the H basis through the Schur functions.

EXAMPLES:

sage: H = MacdonaldPolynomialsH(QQ)
sage: s = SFASchur(H.base_ring())
sage: H._coerce_start(s([2]))
((-q)/(-q*t+1))*McdH[1, 1] + (1/(-q*t+1))*McdH[2]
_multiply(left, right)

EXAMPLES:

sage: H = MacdonaldPolynomialsH(QQ)
sage: H([1])^2 #indirect doctest
((q-1)/(q*t-1))*McdH[1, 1] + ((t-1)/(q*t-1))*McdH[2]
_s_cache(n)

Compute the change of basis and its inverse between the Macdonald polynomials on the H basis and the Schur functions.

EXAMPLES:

sage: H = MacdonaldPolynomialsH(QQ)
sage: H._s_cache(2)
sage: l = lambda c: [ (i[0],[j for j in sorted(i[1].items())]) for i in sorted(c.items())]
sage: l( H._s_to_self_cache[2] )
[([1, 1], [([1, 1], 1/(-q*t + 1)), ([2], (-t)/(-q*t + 1))]),
 ([2], [([1, 1], (-q)/(-q*t + 1)), ([2], 1/(-q*t + 1))])]
sage: l( H._self_to_s_cache[2] )
[([1, 1], [([1, 1], 1), ([2], t)]), ([2], [([1, 1], q), ([2], 1)])]
_to_s(part)

Returns a function which gives the coefficient of a partition in the Schur expansion of self(part).

EXAMPLES:

sage: H = MacdonaldPolynomialsH(QQ)
sage: f21 = H._to_s(Partition([2,1]))
sage: [f21(part) for part in Partitions(3)]
[t, q*t + 1, q]
class sage.combinat.sf.macdonald.MacdonaldPolynomials_ht(R, q=None, t=None)
__init__(R, q=None, t=None)

TESTS:

sage: Ht = MacdonaldPolynomialsHt(QQ)
sage: Ht == loads(dumps(Ht))
True
_coerce_start(x)

Coerce things into the Ht basis though the Schur functions.

EXAMPLES:

sage: Ht = MacdonaldPolynomialsHt(QQ)
sage: s = SFASchur(Ht.base_ring())
sage: Ht._coerce_start(s([2,1]))
((-q)/(-q*t^2+t^3+q^2-q*t))*McdHt[1, 1, 1] + ((q^2+q*t+t^2)/(-q^2*t^2+q^3+t^3-q*t))*McdHt[2, 1] + ((-t)/(q^3-q^2*t-q*t+t^2))*McdHt[3]
sage: Ht._coerce_start(s([2]))
((-q)/(-q+t))*McdHt[1, 1] + (t/(-q+t))*McdHt[2]
_multiply(left, right)

EXAMPLES:

sage: Ht = MacdonaldPolynomialsHt(QQ)
sage: Ht([1])^2 #indirect doctest
((-q+1)/(-q+t))*McdHt[1, 1] + ((t-1)/(-q+t))*McdHt[2]
_s_cache(n)

Compute the change of basis and its inverse between the Macdonald polynomials on the Ht basis and the Schur functions.

EXAMPLES:

sage: Ht = MacdonaldPolynomialsHt(QQ)
sage: Ht._s_cache(2)
sage: l = lambda c: [ (i[0],[j for j in sorted(i[1].items())]) for i in sorted(c.items())]
sage: l( Ht._s_to_self_cache[2] )
[([1, 1], [([1, 1], 1/(-q + t)), ([2], (-1)/(-q + t))]),
 ([2], [([1, 1], (-q)/(-q + t)), ([2], t/(-q + t))])]
sage: l( Ht._self_to_s_cache[2] )
[([1, 1], [([1, 1], t), ([2], 1)]), ([2], [([1, 1], q), ([2], 1)])]
_to_s(part)

Returns a function which gives the coefficient of a partition in the Schur expansion of self(part).

EXAMPLES:

sage: Ht = MacdonaldPolynomialsHt(QQ)
sage: f21 = Ht._to_s(Partition([2,1]))
sage: [f21(part) for part in Partitions(3)]
[1, q + t, q*t]
sage: f22 = Ht._to_s(Partition([2,2]))
sage: [f22(part) for part in Partitions(4)]
[1, q*t + q + t, q^2 + t^2, q^2*t + q*t^2 + q*t, q^2*t^2]
class sage.combinat.sf.macdonald.MacdonaldPolynomials_j(R, q=None, t=None)
__init__(R, q=None, t=None)

TESTS:

sage: J = MacdonaldPolynomialsJ(QQ)
sage: J == loads(dumps(J))
True
_coerce_start(x)

Coerce things into the J basis

1) P basis (proportional) 2) Q basis (proportional) 4) Schur functions ( Lascoux, Lapointe and Morse creation operators on Macdonald polynomials ) 3) Everything else through s

EXAMPLES:

sage: P = MacdonaldPolynomialsP(QQ)
sage: Q = MacdonaldPolynomialsQ(QQ)
sage: J = MacdonaldPolynomialsJ(QQ)
sage: s = SFASchur(P.base_ring())
sage: J._coerce_start(P([2]))
(1/(q*t^2-q*t-t+1))*McdJ[2]
sage: J(Q([2]))
(1/(q^3-q^2-q+1))*McdJ[2]
sage: s(J([2]))
(-q*t+t^2+q-t)*s[1, 1] + (q*t^2-q*t-t+1)*s[2]
sage: J(s([2]))
((q-t)/(q*t^4-q*t^3-q*t^2-t^3+q*t+t^2+t-1))*McdJ[1, 1] + (1/(q*t^2-q*t-t+1))*McdJ[2]
_multiply(left, right)

EXAMPLES:

sage: J = MacdonaldPolynomialsJ(QQ)
sage: J([1])^2 #indirect doctest
((q-1)/(q*t-1))*McdJ[1, 1] + ((t-1)/(q*t-1))*McdJ[2]
sage: J([2])^2
((q^3-q^2-q+1)/(q^3*t^2-q^2*t-q*t+1))*McdJ[2, 2] + ((q^3*t-q^3+q^2*t-q^2-q*t+q-t+1)/(q^4*t^2-q^3*t-q*t+1))*McdJ[3, 1] + ((q*t^2-q*t-t+1)/(q^5*t^2-q^3*t-q^2*t+1))*McdJ[4]
_s_cache(n)

Compute the change of basis and its inverse between the Macdonald polynomials on the J basis and the Schur functions.

EXAMPLES:

sage: J = MacdonaldPolynomialsJ(QQ)
sage: J._s_cache(2)
sage: l = lambda c: [ (i[0],[j for j in sorted(i[1].items())]) for i in sorted(c.items())]
sage: l( J._s_to_j_cache[2] )
[([1, 1], [([1, 1], 1/(t^3 - t^2 - t + 1))]),
 ([2],
  [([1, 1], (q - t)/(q*t^4 - q*t^3 - q*t^2 - t^3 + q*t + t^2 + t - 1)),
   ([2], 1/(q*t^2 - q*t - t + 1))])]
sage: l( J._j_to_s_cache[2] )
[([1, 1], [([1, 1], t^3 - t^2 - t + 1)]),
 ([2], [([1, 1], -q*t + t^2 + q - t), ([2], q*t^2 - q*t - t + 1)])]
_to_s(part)

Returns a function which gives the coefficient of a partition in the Schur expansion of self(part).

EXAMPLES:

sage: J = MacdonaldPolynomialsJ(QQ)
sage: f21 = J._to_s(Partition([2,1]))
sage: [f21(part) for part in Partitions(3)]
[0,
 -q*t^4 + 2*q*t^3 - q*t^2 + t^2 - 2*t + 1,
 q*t^3 - t^4 - q*t^2 + t^3 - q*t + t^2 + q - t]
class sage.combinat.sf.macdonald.MacdonaldPolynomials_p(R, q=None, t=None)
__init__(R, q=None, t=None)

TESTS:

sage: P = MacdonaldPolynomialsP(QQ)
sage: P == loads(dumps(P))
True
_coerce_start(x)

Coerce things into the P basis

1) Q basis (proportional) 2) J basis (proportional) 3) Other symmetric functions

EXAMPLES:

sage: P = MacdonaldPolynomialsP(QQ)
sage: Q = MacdonaldPolynomialsQ(QQ)
sage: J = MacdonaldPolynomialsJ(QQ)
sage: s = SFASchur(P.base_ring())
sage: P._coerce_start(Q([2]))
((q*t^2-q*t-t+1)/(q^3-q^2-q+1))*McdP[2]
sage: P._coerce_start(Q([2,1]))
((-q*t^4+2*q*t^3-q*t^2+t^2-2*t+1)/(-q^4*t+2*q^3*t-q^2*t+q^2-2*q+1))*McdP[2, 1]
sage: P(J([2]))
(q*t^2-q*t-t+1)*McdP[2]
sage: P(J([2,1]))
(-q*t^4+2*q*t^3-q*t^2+t^2-2*t+1)*McdP[2, 1]
sage: P(s([2]))
((q-t)/(q*t-1))*McdP[1, 1] + McdP[2]
sage: P(s([2,1]))
((q*t-t^2+q-t)/(q*t^2-1))*McdP[1, 1, 1] + McdP[2, 1]
_multiply(left, right)

EXAMPLES:

sage: P = MacdonaldPolynomialsP(QQ)
sage: P([1])^2 #indirect doctest
((q*t+q-t-1)/(q*t-1))*McdP[1, 1] + McdP[2]
class sage.combinat.sf.macdonald.MacdonaldPolynomials_q(R, q=None, t=None)
__init__(R, q=None, t=None)

TESTS:

sage: Q = MacdonaldPolynomialsQ(QQ)
sage: Q == loads(dumps(Q))
True
_coerce_start(x)

Coerce things into the Q basis

1) P basis (proportional) 2) J basis (proportional) 3) Other symmetric functions

EXAMPLES:

sage: P = MacdonaldPolynomialsP(QQ)
sage: Q = MacdonaldPolynomialsQ(QQ)
sage: J = MacdonaldPolynomialsJ(QQ)
sage: s = SFASchur(P.base_ring())
sage: Q._coerce_start(J([2]))
(q^3-q^2-q+1)*McdQ[2]
sage: Q(P([2]))
((q^3-q^2-q+1)/(q*t^2-q*t-t+1))*McdQ[2]
sage: P(Q(P([2])))
McdP[2]
sage: Q(P(Q([2])))
McdQ[2]
sage: Q(s([2]))
((q^2-q*t-q+t)/(t^3-t^2-t+1))*McdQ[1, 1] + ((q^3-q^2-q+1)/(q*t^2-q*t-t+1))*McdQ[2]
_multiply(left, right)

EXAMPLES:

sage: J = MacdonaldPolynomialsJ(QQ)
sage: J([1])^2 #indirect doctest
((q-1)/(q*t-1))*McdJ[1, 1] + ((t-1)/(q*t-1))*McdJ[2]
class sage.combinat.sf.macdonald.MacdonaldPolynomials_s(R, q=None, t=None)
__init__(R, q=None, t=None)

TESTS:

sage: S = MacdonaldPolynomialsS(QQ)
sage: S == loads(dumps(S))
True
_coerce_start(x)

Coerce things into the S basis though the Schur functions.

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: J = MacdonaldPolynomialsJ(QQ)
sage: S._coerce_start(J([2]))
q*McdS[1, 1] + ((-1)/(-1))*McdS[2]
sage: S._coerce_start(J([1,1]))
McdS[1, 1] + t*McdS[2]
_multiply(left, right)

The multiplication of the modified Schur functions behaves the same as the multiplication of the Schur functions.

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: S([2])^2 #indirect doctest
McdS[2, 2] + McdS[3, 1] + McdS[4]
_s_cache(n)

Compute the change of basis and its inverse between the Macdonald polynomials on the S basis and the Schur functions.

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: S._s_cache(2)
sage: l = lambda c: [ (i[0],[j for j in sorted(i[1].items())]) for i in sorted(c.items())]
sage: l( S._s_to_self_cache[2] )
[([1, 1], [([1, 1], 1/(t^3 - t^2 - t + 1)), ([2], t/(t^3 - t^2 - t + 1))]), ([2], [([1, 1], t/(t^3 - t^2 - t + 1)), ([2], (-1)/(-t^3 + t^2 + t - 1))])]
sage: l( S._self_to_s_cache[2] )
[([1, 1], [([1, 1], -t + 1), ([2], t^2 - t)]), ([2], [([1, 1], t^2 - t), ([2], -t + 1)])]
_to_s(part)

Returns a function which gives the coefficient of a partition in the Schur expansion of self(part).

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: S2 = S._to_s(Partition([2]))
sage: S2(Partition([2]))
-t + 1
sage: S2(Partition([1,1]))
t^2 - t
sage.combinat.sf.macdonald._set_cache(c, self)

Since the Macdonald polynomials could be called many ways, this is a utility routine that adds those other ways to the cache.

EXAMPLES:

sage: S = MacdonaldPolynomialsS(QQ)
sage: R = QQ['q,t'].fraction_field()
sage: q,t = R.gens()
sage: S2 = MacdonaldPolynomialsS(R,q,t)
sage: S2 is S #indirect doctest
True
sage.combinat.sf.macdonald.c1(part, q, t)

This function returns the qt-Hall scalar product between J(part) and P(part).

EXAMPLES:

sage: from sage.combinat.sf.macdonald import c1
sage: R.<q,t> = QQ[]
sage: c1(Partition([2,1]),q,t)
-q^4*t + 2*q^3*t - q^2*t + q^2 - 2*q + 1
sage: c1(Partition([1,1]),q,t)
q^2*t - q*t - q + 1
sage.combinat.sf.macdonald.c2(part, q, t)

This function returns the qt-Hall scalar product between J(part) and Q(part).

EXAMPLES:

sage: from sage.combinat.sf.macdonald import c2
sage: R.<q,t> = QQ[]
sage: c2(Partition([1,1]),q,t)
t^3 - t^2 - t + 1
sage: c2(Partition([2,1]),q,t)
-q*t^4 + 2*q*t^3 - q*t^2 + t^2 - 2*t + 1
sage.combinat.sf.macdonald.qt_kostka(lam, mu)

Returns the K_{\lambda\mu}(q,t) by computing the change of basis from the Macdonald H basis to the Schurs.

EXAMPLES:

sage: from sage.combinat.sf.macdonald import qt_kostka
sage: qt_kostka([2,1,1],[1,1,1,1])
t^3 + t^2 + t
sage: qt_kostka([1,1,1,1],[2,1,1])
q
sage: qt_kostka([1,1,1,1],[3,1])
q^3
sage: qt_kostka([1,1,1,1],[1,1,1,1])
1
sage: qt_kostka([2,1,1],[2,2])
q^2*t + q*t + q
sage: qt_kostka([2,2],[2,2])
q^2*t^2 + 1
sage: qt_kostka([4],[3,1])
t
sage: qt_kostka([2,2],[3,1])
q^2*t + q
sage: qt_kostka([3,1],[2,1,1])
q*t^3 + t^2 + t
sage: qt_kostka([2,1,1],[2,1,1])
q*t^2 + q*t + 1
sage: qt_kostka([2,1],[1,1,1,1])
0

Previous topic

LLT Polynomials

Next topic

Non-symmetric Macdonald Polynomials

This Page