Macdonald Polynomials

Notation used in the definitions follows mainly [Macdonald1995].

The integral forms of the bases \(H\) and \(Ht\) do not appear in Macdonald’s book. They correspond to the two bases \(H_\mu[X;q,t] = \sum_{\nu} K_{\nu\mu}(q,t) s_\mu[X]\) and \({\tilde H}_\mu[X;q,t] = t^{n(\mu)} \sum_{\nu} K_{\nu\mu}(q,1/t) s_\nu[X]\) where \(K_{\mu\nu}(q,t)\) are the Macdonald \(q,t\)-Koskta coefficients.

The \(Ht\) in this case is short for \({\tilde H}\) and is the basis which is the graded Frobenius image of the Garsia-Haiman modules [GH1993].

REFERENCES:

[Macdonald1995]

(1, 2, 3, 4) I. G. Macdonald, Symmetric functions and Hall polynomials, second ed., The Clarendon Press, Oxford University Press, New York, 1995, With contributions by A. Zelevinsky, Oxford Science Publications.

[GH1993]

A. Garsia, M. Haiman, A graded representation module for Macdonald’s polynomials, Proc. Nat. Acad. U.S.A. no. 90, 3607–3610.

[BGHT1999]

(1, 2) F. Bergeron, A. M. Garsia, M. Haiman, and G. Tesler, Identities and positivity conjectures for some remarkable operators in the theory of symmetric functions, Methods Appl. Anal. 6 (1999), no. 3, 363–420.

[LLM1998]

(1, 2) L. Lapointe, A. Lascoux, J. Morse, Determinantal Expressions for Macdonald Polynomials, IRMN no. 18 (1998). Arxiv math/9808050.

class sage.combinat.sf.macdonald.Macdonald(Sym, q='q', t='t')

Bases: sage.structure.unique_representation.UniqueRepresentation

Macdonald Symmetric functions including \(P\), \(Q\), \(J\), \(H\), \(Ht\) bases also including the S basis which is the plethystic transformation of the Schur basis (that which is dual to the Schur basis with respect to the Macdonald \(q,t\)-scalar product)

INPUT:

• self – a family of Macdonald symmetric function bases

EXAMPLES

sage: t = QQ['t'].gen(); SymmetricFunctions(QQ['t'].fraction_field()).macdonald(q=t,t=1)
Macdonald polynomials with q=t and t=1 over Fraction Field of Univariate Polynomial Ring in t over Rational Field
sage: Sym = SymmetricFunctions(FractionField(QQ['t'])).macdonald()
Traceback (most recent call last):
...
ValueError: parameter q must be in the base ring

H()

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.

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• returns the \(H\) Macdonald basis of symmetric functions

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: H = Sym.macdonald().H(); H
Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field in the Macdonald H basis
sage: s = Sym.schur()
sage: s(H([2]))
q*s[1, 1] + s[2]
sage: s(H([1,1]))
s[1, 1] + t*s[2]

Coercions to/from the Schur basis are implemented:

sage: H = Sym.macdonald().H()
sage: s = Sym.schur()
sage: H(s([2]))
((-q)/(-q*t+1))*McdH[1, 1] + (1/(-q*t+1))*McdH[2]

Ht()

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.

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• returns the \(Ht\) Macdonald basis of symmetric functions

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: Ht = Sym.macdonald().Ht(); Ht
Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field in the Macdonald Ht basis
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 = Sym.schur()
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

Coercions to/from the Schur basis are implemented:

sage: Ht = Sym.macdonald().Ht()
sage: s = Sym.schur()
sage: Ht(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(s([2]))
((-q)/(-q+t))*McdHt[1, 1] + (t/(-q+t))*McdHt[2]

J()

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.

The \(J\) basis is calculated using determinantal formulas of Lapointe-Lascoux-Morse giving the action on the S-basis [LLM1998].

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• returns the \(J\) Macdonald basis of symmetric functions

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: J = Sym.macdonald().J(); J
Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field in the Macdonald J basis
sage: P = Sym.macdonald().P()
sage: Q = Sym.macdonald().Q()
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]

Coercions from the \(Q\) and \(J\) basis (proportional) and to/from the Schur basis are implemented:

sage: P = Sym.macdonald().P()
sage: Q = Sym.macdonald().Q()
sage: J = Sym.macdonald().J()
sage: s = Sym.schur()

sage: J(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]

P()

Returns Macdonald polynomials in \(P\) basis. The \(P\) basis is defined here as a normalized form of the \(J\) basis.

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• returns the \(P\) Macdonald basis of symmetric functions

EXAMPLES

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P(); P
Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field in the Macdonald P basis
sage: P[2]
McdP[2]

The \(P\) Macdonald basis is upper triangularly related to the monomial symmetric functions and are orthogonal with respect to the \(qt\)-Hall scalar product:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P(); P
Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field in the Macdonald P basis
sage: m = Sym.monomial()
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: Sym = SymmetricFunctions(FractionField(QQ['t']))
sage: P = Sym.macdonald(q=0).P(); P
Symmetric Functions over Fraction Field of Univariate Polynomial Ring in t over Rational Field in the Macdonald P with q=0 basis
sage: P([2])^2
(t+1)*McdP[2, 2] + (-t+1)*McdP[3, 1] + McdP[4]
sage: HLP = Sym.hall_littlewood().P()
sage: HLP([2])^2
(t+1)*HLP[2, 2] + (-t+1)*HLP[3, 1] + HLP[4]

Coercions from the \(Q\) and \(J\) basis (proportional) are implemented:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P()
sage: Q = Sym.macdonald().Q()
sage: J = Sym.macdonald().J()
sage: s = Sym.schur()

sage: P(Q([2]))
((q*t^2-q*t-t+1)/(q^3-q^2-q+1))*McdP[2]
sage: P(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]

By transitivity, one get coercions from the classical bases:

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]

sage: Sym = SymmetricFunctions(QQ['x','y','z'].fraction_field())
sage: (x,y,z) = Sym.base_ring().gens()
sage: Macxy = Sym.macdonald(q=x,t=y)
sage: Macyz = Sym.macdonald(q=y,t=z)
sage: Maczx = Sym.macdonald(q=z,t=x)
sage: P1 = Macxy.P()
sage: P2 = Macyz.P()
sage: P3 = Maczx.P()
sage: m(P1[2,1])
((-2*x*y^2+x*y-y^2+x-y+2)/(-x*y^2+1))*m[1, 1, 1] + m[2, 1]
sage: m(P2[2,1])
((-2*y*z^2+y*z-z^2+y-z+2)/(-y*z^2+1))*m[1, 1, 1] + m[2, 1]
sage: m(P1(P2(P3[2,1])))
((-2*x^2*z-x^2+x*z-x+z+2)/(-x^2*z+1))*m[1, 1, 1] + m[2, 1]
sage: P1(P2[2])
((-x*y^2+2*x*y*z-y^2*z-x+2*y-z)/(x*y^2*z-x*y-y*z+1))*McdP[1, 1] + McdP[2]
sage: m(z*P1[2]+x*P2[2])
((x^2*y^2*z+x*y^2*z^2-x^2*y^2+x^2*y*z-x*y*z^2+y^2*z^2-x^2*y-2*x*y*z-y*z^2+x*y-y*z+x+z)/(x*y^2*z-x*y-y*z+1))*m[1, 1] + (x+z)*m[2]

Q()

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. The \(Q\) basis is defined to be a normalized form of the \(J\) basis.

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• returns the \(Q\) Macdonald basis of symmetric functions

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: Q = Sym.macdonald().Q(); Q
Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field in the Macdonald Q basis
sage: P = Sym.macdonald().P()
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]

Coercions from the \(P\) and \(J\) basis (proportional) are implemented:

sage: P = Sym.macdonald().P()
sage: Q = Sym.macdonald().Q()
sage: J = Sym.macdonald().J()
sage: s = Sym.schur()

sage: Q(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]

By transitivity, one gets coercions from the classical bases:

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]

S()

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

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• returns the \(S\) Macdonald basis of symmetric functions

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: S = Sym.macdonald().S(); S
Symmetric Functions over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field in the Macdonald S basis
sage: p = Sym.power()
sage: p(S[2,1])
((1/3*t^3-t^2+t-1/3)/(q^3-3*q^2+3*q-1))*p[1, 1, 1] + ((-1/3*t^3+1/3)/(q^3-1))*p[3]
sage: J = Sym.macdonald().J()
sage: S(J([2]))
(q^3-q^2-q+1)*McdS[2]
sage: S(J([1,1]))
(q^2*t-q*t-q+1)*McdS[1, 1] + (q^2-q*t-q+t)*McdS[2]
sage: S = Sym.macdonald(q=0).S()
sage: S(J[1,1])
McdS[1, 1] + t*McdS[2]
sage: S(J[2])
q*McdS[1, 1] + McdS[2]
sage: p(S[2,1])
(-1/3*t^3+t^2-t+1/3)*p[1, 1, 1] + (1/3*t^3-1/3)*p[3]

sage: from sage.combinat.sf.macdonald import qt_kostka
sage: qt_kostka([2],[1,1])
t
sage: qt_kostka([1,1],[2])
q

Coercions to/from the Schur basis are implemented:

sage: S = Sym.macdonald().S()
sage: s = Sym.schur()
sage: S(s([2]))
((q^2-q*t-q+t)/(t^3-t^2-t+1))*McdS[1, 1] + ((-q^2*t+q*t+q-1)/(-t^3+t^2+t-1))*McdS[2]
sage: s(S([1,1]))
((-q*t^2+q*t+t-1)/(-q^3+q^2+q-1))*s[1, 1] + ((q*t-t^2-q+t)/(-q^3+q^2+q-1))*s[2]

base_ring()

Returns the base ring of the symmetric functions where the Macdonald symmetric functions live

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• the base ring associated to the corresponding symmetric function ring

EXAMPLES

sage: Sym = SymmetricFunctions(QQ['q'].fraction_field())
sage: Mac = Sym.macdonald(t=0)
sage: Mac.base_ring()
Fraction Field of Univariate Polynomial Ring in q over Rational Field

symmetric_function_ring()

Returns the base ring of the symmetric functions where the Macdonald symmetric functions live

INPUT:

• self – a family of Macdonald symmetric function bases

OUTPUT:

• the symmetric function ring associated to the Macdonald bases

EXAMPLES

sage: Mac = SymmetricFunctions(QQ['q'].fraction_field()).macdonald(t=0)
sage: Mac.symmetric_function_ring()
Symmetric Functions over Fraction Field of Univariate Polynomial Ring in q over Rational Field

class sage.combinat.sf.macdonald.MacdonaldPolynomials_generic(macdonald)

Bases: sage.combinat.sf.sfa.SymmetricFunctionAlgebra_generic

A class for methods for one of the Macdonald bases of the symmetric functions

INPUT:

• self – a Macdonald basis
• macdonald – a family of Macdonald symmetric function bases

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q,t'])); Sym.rename("Sym"); Sym
Sym
sage: Sym.macdonald().P()
Sym in the Macdonald P basis
sage: Sym.macdonald(t=2).P()
Sym in the Macdonald P with t=2 basis
sage: Sym.rename()

TESTS:

sage: Sym.macdonald().P()._prefix
'McdP'
sage: Sym.macdonald().Ht()._prefix
'McdHt'

class Element(M, x)

Bases: sage.combinat.sf.sfa.SymmetricFunctionAlgebra_generic_Element

Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.

TESTS:

sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True

nabla(q=None, t=None, power=1)

Returns the value of the nabla operator applied to self. The eigenvectors of the nabla operator are the Macdonald polynomials in the \(Ht\) basis. For more information see: [BGHT1999].

The operator nabla acts on symmetric functions and has the Macdonald \(Ht\) basis as eigenfunctions and the eigenvalues are \(q^{n(\mu')} t^{n(\mu)}\) where \(n(\mu) = \sum_{i} (i-1) \mu_i\).

If the parameter power is an integer then it calculates nabla to that integer. The default value of power is 1.

INPUT:

• self – an element of a Macdonald basis
• q, t – optional parameters to specialize
• power – an integer (default: 1)

OUTPUT:

• returns the symmetric function of \(\nabla\) acting on self

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P()
sage: P([1,1]).nabla()
((q^2*t+q*t^2-2*t)/(q*t-1))*McdP[1, 1] + McdP[2]
sage: P([1,1]).nabla(t=1)
((q^2*t+q*t-t-1)/(q*t-1))*McdP[1, 1] + McdP[2]
sage: H = Sym.macdonald().H()
sage: H([1,1]).nabla()
t*McdH[1, 1] + (-t^2+1)*McdH[2]
sage: H([1,1]).nabla(q=1)
((t^2+q-t-1)/(q*t-1))*McdH[1, 1] + ((-t^3+t^2+t-1)/(q*t-1))*McdH[2]
sage: H(0).nabla()
0
sage: H([2,2,1]).nabla(t=1/H.t)  # long time (4s on sage.math, 2012)
q^2/t^4*McdH[2, 2, 1]
sage: H([2,2,1]).nabla(t=1/H.t,power=-1)  # long time (4s on sage.math, 2013)
t^4/q^2*McdH[2, 2, 1]

MacdonaldPolynomials_generic.c1(part)

Returns the qt-Hall scalar product between J(part) and P(part).

INPUT:

• self – a Macdonald basis
• part – a partition

OUTPUT:

• returns the \(qt\)-Hall scalar product between J(part) and P(part)

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P()
sage: P.c1(Partition([2,1]))
-q^4*t + 2*q^3*t - q^2*t + q^2 - 2*q + 1

MacdonaldPolynomials_generic.c2(part)

Returns the \(qt\)-Hall scalar product between J(part) and Q(part).

INPUT:

• self – a Macdonald basis
• part – a partition

OUTPUT:

• returns the \(qt\)-Hall scalar product between J(part) and Q(part)

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P()
sage: P.c2(Partition([2,1]))
-q*t^4 + 2*q*t^3 - q*t^2 + t^2 - 2*t + 1

MacdonaldPolynomials_generic.macdonald_family()

Returns the family of Macdonald bases associated to the basis self

INPUT:

• self – a Macdonald basis

OUTPUT:

• the family of Macdonald symmetric functions associated to self

EXAMPLES

sage: MacP = SymmetricFunctions(QQ['q'].fraction_field()).macdonald(t=0).P()
sage: MacP.macdonald_family()
Macdonald polynomials with t=0 over Fraction Field of Univariate Polynomial Ring in q over Rational Field

class sage.combinat.sf.macdonald.MacdonaldPolynomials_h(macdonald)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic

The \(H\) basis is expanded in the Schur basis by extracting the \(q,t\)-Kostka coefficient through the \(t\)-scalar product of \(J_{\mu}\) and \(s_{\lambda}\).

INPUT:

• self – a Macdonald \(H\) basis
• macdonald – a family of Macdonald bases

TESTS:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: H = Sym.macdonald().H()
sage: TestSuite(H).run(skip=["_test_associativity","_test_distributivity","_test_prod"])
sage: TestSuite(H).run(elements = [H.t*H[1,1]+H.q*H[2], H[1]+(H.q+H.t)*H[1,1]])  # long time (26s on sage.math, 2012)

class Element(M, x)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic.Element

Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.

TESTS:

sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True

class sage.combinat.sf.macdonald.MacdonaldPolynomials_ht(macdonald)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic

The \(Ht\) basis is defined from the \(H\) basis by replacing \(t \to 1/t\) and multiplying by a normalizing power of \(t\).

INPUT:

• self – a Macdonald \(Ht\) basis
• macdonald – a family of Macdonald bases

TESTS:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: Ht = Sym.macdonald().Ht()
sage: TestSuite(Ht).run(skip=["_test_associativity","_test_distributivity","_test_prod"])  # long time (26s on sage.math, 2012)
sage: TestSuite(Ht).run(elements = [Ht.t*Ht[1,1]+Ht.q*Ht[2], Ht[1]+(Ht.q+Ht.t)*Ht[1,1]])  # long time (depends on previous)

class Element(M, x)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic.Element

Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.

TESTS:

sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True

nabla(q=None, t=None, power=1)

Returns the value of the nabla operator applied to self. The eigenvectors of the \(nabla\) operator are the Macdonald polynomials in the \(Ht\) basis. For more information see: [BGHT1999].

The operator \(nabla\) acts on symmetric functions and has the Macdonald \(Ht\) basis as eigenfunctions and the eigenvalues are \(q^{n(\mu')} t^{n(\mu)}\) where \(n(\mu) = \sum_{i} (i-1) \mu_i\).

If the parameter power is an integer then it calculates nabla to that integer. The default value of power is 1.

INPUT:

• self – an element of the Macdonald \(Ht\) basis
• q, t – optional parameters to specialize
• power – an integer (default: 1)

OUTPUT:

• returns the symmetric function of \(\nabla\) acting on self

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: Ht = Sym.macdonald().Ht()
sage: t = Ht.t; q = Ht.q;
sage: s = Sym.schur()
sage: a = sum(Ht(p) for p in Partitions(3))
sage: Ht(0).nabla()
0
sage: a.nabla() == t^3*Ht([1,1,1])+q*t*Ht([2,1]) + q^3*Ht([3])
True
sage: a.nabla(t=3) == 27*Ht([1,1,1])+3*q*Ht([2,1]) + q^3*Ht([3])
True
sage: a.nabla(q=3) == t^3*Ht([1,1,1])+3*t*Ht([2,1]) + 27*Ht([3])
True
sage: Ht[2,1].nabla(power=-1)
1/(q*t)*McdHt[2, 1]
sage: Ht[2,1].nabla(power=4)
q^4*t^4*McdHt[2, 1]
sage: s(a.nabla(q=3))
(t^6+27*q^3+3*q*t^2)*s[1, 1, 1] + (t^5+t^4+27*q^2+3*q*t+3*t^2+27*q)*s[2, 1] + (t^3+3*t+27)*s[3]
sage: Ht = Sym.macdonald(q=3).Ht()
sage: a = sum(Ht(p) for p in Partitions(3))
sage: s(a.nabla())
(t^6+9*t^2+729)*s[1, 1, 1] + (t^5+t^4+3*t^2+9*t+324)*s[2, 1] + (t^3+3*t+27)*s[3]

class sage.combinat.sf.macdonald.MacdonaldPolynomials_j(macdonald)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic

The \(J\) basis is calculated using determinantal formulas of Lapointe-Lascoux-Morse giving the action on the \(S\)-basis.

INPUT:

• self – a Macdonald \(J\) basis
• macdonald – a family of Macdonald bases

TESTS:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: J = Sym.macdonald().J()
sage: TestSuite(J).run(skip=["_test_associativity","_test_distributivity","_test_prod"])  # long time (19s on sage.math, 2012)
sage: TestSuite(J).run(elements = [J.t*J[1,1]+J.q*J[2], J[1]+(J.q+J.t)*J[1,1]])  # long time (depends on previous)

class Element(M, x)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic.Element

Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.

TESTS:

sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True

class sage.combinat.sf.macdonald.MacdonaldPolynomials_p(macdonald)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic

The \(P\) basis is defined here as the \(J\) basis times a normalizing coefficient \(c2\).

INPUT:

• self – a Macdonald \(P\) basis
• macdonald – a family of Macdonald bases

TESTS:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P()
sage: TestSuite(P).run(skip=["_test_associativity","_test_distributivity","_test_prod"])  # long time (20s on sage.math, 2012)
sage: TestSuite(P).run(elements = [P.t*P[1,1]+P.q*P[2], P[1]+(P.q+P.t)*P[1,1]])  # long time (depends on previous)

class Element(M, x)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic.Element

Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.

TESTS:

sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True

MacdonaldPolynomials_p.scalar_qt_basis(part1, part2=None)

Returns the scalar product of \(P(part1)\) and \(P(part2)\) This scalar product formula is given in equation (4.11) p.323 and (6.19) p.339 of Macdonald’s book [Macdonald1995].

INPUT:

• self – a Macdonald \(P\) basis
• part1, part2 – partitions

OUTPUT:

• returns the scalar product of P(part1) and P(part2)

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: P = Sym.macdonald().P()
sage: P.scalar_qt_basis(Partition([2,1]), Partition([1,1,1]))
0
sage: f = P.scalar_qt_basis(Partition([3,2,1]), Partition([3,2,1]))
sage: factor(f.numerator())
(q - 1)^3 * (q^2*t - 1)^2 * (q^3*t^2 - 1)
sage: factor(f.denominator())
(t - 1)^3 * (q*t^2 - 1)^2 * (q^2*t^3 - 1)

With a single argument, takes \(part2 = part1\):

sage: P.scalar_qt_basis(Partition([2,1]), Partition([2,1]))
(-q^4*t + 2*q^3*t - q^2*t + q^2 - 2*q + 1)/(-q*t^4 + 2*q*t^3 - q*t^2 + t^2 - 2*t + 1)

class sage.combinat.sf.macdonald.MacdonaldPolynomials_q(macdonald)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic

The \(Q\) basis is defined here as the \(J\) basis times a normalizing coefficient.

INPUT:

• self – a Macdonald \(Q\) basis
• macdonald – a family of Macdonald bases

TESTS:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: Q = Sym.macdonald().Q()
sage: TestSuite(Q).run(skip=["_test_associativity","_test_distributivity","_test_prod"])  # long time (29s on sage.math, 2012)
sage: TestSuite(Q).run(elements = [Q.t*Q[1,1]+Q.q*Q[2], Q[1]+(Q.q+Q.t)*Q[1,1]])  # long time (depends on previous)

class Element(M, x)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic.Element

Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.

TESTS:

sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True

class sage.combinat.sf.macdonald.MacdonaldPolynomials_s(macdonald)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic

An implementation of the basis \(s_\lambda[(1-t)X/(1-q)]\)

This is perhaps misnamed as a ‘Macdonald’ basis for the symmetric functions but is used in the calculation of the Macdonald \(J\) basis (see method ‘creation’ below) but does use both of the two parameters and can be specialized to \(s_\lambda[(1-t)X]\) and \(s_\lambda[X/(1-t)]\).

INPUT:

• self – a Macdonald \(S\) basis
• macdonald – a family of Macdonald bases

TESTS:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: S = Sym.macdonald().S()
sage: TestSuite(S).run(skip=["_test_associativity","_test_distributivity","_test_prod"])
sage: TestSuite(S).run(elements = [S.t*S[1,1]+S.q*S[2], S[1]+(S.q+S.t)*S[1,1]])

class Element(M, x)

Bases: sage.combinat.sf.macdonald.MacdonaldPolynomials_generic.Element

Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.

TESTS:

sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True

creation(k)

This function is a creation operator for the J-basis for which the action is known on the ‘Macdonald’ S-basis by formula from [LLM1998].

INPUT:

• self – an element of the Macdonald \(S\) basis
• k – a positive integer

OUTPUT:

• returns the column adding operator on the \(J\) basis on self

EXAMPLES:

sage: Sym = SymmetricFunctions(FractionField(QQ['q','t']))
sage: S = Sym.macdonald().S()
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]

sage.combinat.sf.macdonald.c1(part, q, t)

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

This coefficient is \(c_\lambda\) in equation (8.1’) p. 352 of Macdonald’s book [Macdonald1995].

INPUT:

• part – a partition
• q, t – parameters

OUTPUT:

• returns a polynomial of the scalar product between the \(J\) and \(P\) bases

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

This coefficient is \(c_\lambda\) in equation (8.1) p. 352 of Macdonald’s book [Macdonald1995].

INPUT:

• part – a partition
• q, t – parameters

OUTPUT:

• returns a polynomial of the scalar product between the \(J\) and \(P\) bases

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.

INPUT:

• lam, mu – partitions of the same size

OUTPUT:

• returns the \(q,t\)-Kostka polynomial indexed by the partitions lam and mu

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