18.35 Macdonald Polynomials - under development

Module: sage.combinat.sf.macdonald

Macdonald Polynomials - under development.

Module-level Functions

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.

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]

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.

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

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.

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]

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.

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]

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.

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]

MacdonaldPolynomialsS( R, [q=None], [t=None])

Returns the modified Schur functions defined by the plethystic subsitution $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.

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

c1( part, q, t)

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

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

c2( part, q, t)

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

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

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.

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

Class: MacdonaldPolynomial_generic

class MacdonaldPolynomial_generic

Functions: nabla, $\,$ omega_qt, $\,$ scalar_qt

nabla( self)

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

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( self)

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

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( self, x)

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

sage: H = MacdonaldPolynomialsH(QQ)
sage: H([1]).scalar_qt(H([1]))
(-q + 1)/(-t + 1)

Class: MacdonaldPolynomial_h

class MacdonaldPolynomial_h

Class: MacdonaldPolynomial_ht

class MacdonaldPolynomial_ht

Functions: nabla

nabla( self)

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

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: MacdonaldPolynomial_j

class MacdonaldPolynomial_j

Functions: scalar_qt

scalar_qt( self, 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.

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: MacdonaldPolynomial_p

class MacdonaldPolynomial_p

Functions: scalar_qt

scalar_qt( self, 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.

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: MacdonaldPolynomial_q

class MacdonaldPolynomial_q

Functions: scalar_qt

scalar_qt( self, 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.

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: MacdonaldPolynomial_s

class MacdonaldPolynomial_s

Functions: creation, $\,$ omega_qt

creation( self, k)

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( self)

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

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]

Special Functions: _creation_by_determinant, $\,$ _creation_by_determinant_helper, $\,$ _omega_qt_in_schurs

_creation_by_determinant( self, k)

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( self, k, part)

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( self)

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

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

Class: MacdonaldPolynomials_generic

class MacdonaldPolynomials_generic

MacdonaldPolynomials_generic( self, R, [q=None], [t=None])

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

Special Functions: __init__

Class: MacdonaldPolynomials_h

class MacdonaldPolynomials_h

MacdonaldPolynomials_h( self, R, [q=None], [t=None])

TESTS:

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

Special Functions: __init__, $\,$ _coerce_start, $\,$ _multiply, $\,$ _s_cache, $\,$ _to_s

_coerce_start( self, x)

Coerce things into the H basis through the Schur functions.

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( self, left, right)

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( self, n)

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

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( self, part)

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

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: MacdonaldPolynomials_ht

class MacdonaldPolynomials_ht

MacdonaldPolynomials_ht( self, R, [q=None], [t=None])

TESTS:

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

Special Functions: __init__, $\,$ _coerce_start, $\,$ _multiply, $\,$ _s_cache, $\,$ _to_s

_coerce_start( self, x)

Coerce things into the Ht basis though the Schur functions.

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( self, left, right)

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( self, n)

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

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( self, part)

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

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: MacdonaldPolynomials_j

class MacdonaldPolynomials_j

MacdonaldPolynomials_j( self, R, [q=None], [t=None])

TESTS:

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

Special Functions: __init__, $\,$ _coerce_start, $\,$ _multiply, $\,$ _s_cache, $\,$ _to_s

_coerce_start( self, 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

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( self, left, right)

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( self, n)

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

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( self, part)

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

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: MacdonaldPolynomials_p

class MacdonaldPolynomials_p

MacdonaldPolynomials_p( self, R, [q=None], [t=None])

TESTS:

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

Special Functions: __init__, $\,$ _coerce_start, $\,$ _multiply

_coerce_start( self, x)

Coerce things into the P basis

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

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( self, left, right)

sage: P = MacdonaldPolynomialsP(QQ)
sage: P([1])^2 #indirect doctest
((q*t+q-t-1)/(q*t-1))*McdP[1, 1] + McdP[2]

Class: MacdonaldPolynomials_q

class MacdonaldPolynomials_q

MacdonaldPolynomials_q( self, R, [q=None], [t=None])

TESTS:

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

Special Functions: __init__, $\,$ _coerce_start, $\,$ _multiply

_coerce_start( self, x)

Coerce things into the Q basis

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

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( self, left, right)

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: MacdonaldPolynomials_s

class MacdonaldPolynomials_s

MacdonaldPolynomials_s( self, R, [q=None], [t=None])

TESTS:

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

Special Functions: __init__, $\,$ _coerce_start, $\,$ _multiply, $\,$ _s_cache, $\,$ _to_s

_coerce_start( self, x)

Coerce things into the S basis though the Schur functions.

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( self, left, right)

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

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

_s_cache( self, n)

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

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( self, part)

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

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

See About this document... for information on suggesting changes.