Coverage for local/lib/python2.7/site-packages/sage/combinat/sf/jack.py: 64%

Set of Homomorphisms from Symmetric Functions over Fraction Field of Univariate Polynomial Ring in t over Rational Field in the Jack P basis to Symmetric Functions over Fraction Field of Univariate Polynomial Ring in t over Rational Field in the Jack P basis

sage: normal.category_for()

Category of algebras with basis over Fraction Field of Univariate Polynomial Ring in t over Rational Field

sage: t = JP.t

sage: a = 2/(1/2*t+1/2)

sage: b = 1/(1/3+1/6*t)

sage: c = 24/(4*t^2 + 12*t + 8)

sage: normal( a*JP[1] + b*JP[2] + c*JP[2,1] )

(4/(t+1))*JackP[1] + (6/(t+2))*JackP[2] + (6/(t^2+3*t+2))*JackP[2, 1]

.. TODO::

This method should not be needed once short idioms to

construct morphisms are available

"""

return SetMorphism(End(self, category), self._normalize)

def _multiply(self, left, right):

r"""

The product of two Jack symmetric functions is done by multiplying the

elements in the `P` basis and then expressing the elements

the basis ``self``.

INPUT:

- ``self`` -- a Jack basis of the symmetric functions

- ``left``, ``right`` -- symmetric function elements

OUTPUT:

- returns the product of ``left`` and ``right`` expanded in the basis ``self``

EXAMPLES::

sage: JJ = SymmetricFunctions(FractionField(QQ['t'])).jack().J()

sage: JJ([1])^2 # indirect doctest

(t/(t+1))*JackJ[1, 1] + (1/(t+1))*JackJ[2]

sage: JJ([2])^2

(2*t^2/(2*t^2+3*t+1))*JackJ[2, 2] + (4*t/(3*t^2+4*t+1))*JackJ[3, 1] + ((t+1)/(6*t^2+5*t+1))*JackJ[4]

sage: JQ = SymmetricFunctions(FractionField(QQ['t'])).jack().Q()

sage: JQ([1])^2 # indirect doctest

JackQ[1, 1] + (2/(t+1))*JackQ[2]

sage: JQ([2])^2

JackQ[2, 2] + (2/(t+1))*JackQ[3, 1] + ((6*t+6)/(6*t^2+5*t+1))*JackQ[4]

"""

return self( self._P(left)*self._P(right) )

def jack_family( self ):

r"""

Returns the family of Jack bases associated to the basis ``self``

INPUT:

- ``self`` -- a Jack basis of the symmetric functions

OUTPUT:

- the family of Jack symmetric functions associated to ``self``

EXAMPLES::

sage: JackP = SymmetricFunctions(QQ).jack(t=2).P()

sage: JackP.jack_family()

Jack polynomials with t=2 over Rational Field

"""

return self._jack

def coproduct_by_coercion(self, elt):

r"""

Returns the coproduct of the element ``elt`` by coercion to the Schur basis.

INPUT:

- ``self`` -- a Jack symmetric function basis

- ``elt`` -- an instance of this basis

OUTPUT:

- The coproduct acting on ``elt``, the result is an element of the

tensor squared of the Jack symmetric function basis

EXAMPLES::

sage: Sym = SymmetricFunctions(QQ['t'].fraction_field())

sage: Sym.jack().P()[2,2].coproduct() #indirect doctest

JackP[] # JackP[2, 2] + (2/(t+1))*JackP[1] # JackP[2, 1] + ((8*t+4)/(t^3+4*t^2+5*t+2))*JackP[1, 1] # JackP[1, 1] + JackP[2] # JackP[2] + (2/(t+1))*JackP[2, 1] # JackP[1] + JackP[2, 2] # JackP[]

"""

from sage.categories.tensor import tensor

s = self.realization_of().schur()

g = self.tensor_square().sum(coeff*tensor([self(s[x]), self(s[y])])

for ((x,y), coeff) in s(elt).coproduct())

normalize = self._normalize_coefficients

return self.tensor_square().sum(normalize(coeff)*tensor([self(x), self(y)])

for ((x,y), coeff) in g)

class Element(sfa.SymmetricFunctionAlgebra_generic.Element):

def scalar_jack(self, x, t=None):

r"""

A scalar product where the power sums are orthogonal and

`\langle p_\mu, p_\mu \rangle = z_\mu t^{length(\mu)}`

INPUT:

- ``self`` -- an element of a Jack basis of the symmetric functions

- ``x`` -- an element of the symmetric functions

- ``t`` -- an optional parameter (default : None uses the parameter from

the basis)

OUTPUT:

- returns the Jack scalar product between ``x`` and ``self``

EXAMPLES::

sage: Sym = SymmetricFunctions(FractionField(QQ['t']))

sage: JP = Sym.jack().P()

sage: JQ = Sym.jack().Q()

sage: p = Partitions(3).list()

sage: matrix([[JP(a).scalar_jack(JQ(b)) for a in p] for b in p])

[1 0 0]

[0 1 0]

[0 0 1]

"""

parent = self.parent()

p = parent.realization_of().power()

res = p(self).scalar_jack(p(x), t)

return parent._normalize_coefficients(res)

def part_scalar_jack(part1, part2, t):

r"""

Returns the Jack scalar product between ``p(part1)`` and ``p(part2)`` where

`p` is the power-sum basis.

INPUT:

- ``part1``, ``part2`` -- two partitions

- ``t`` -- a parameter

OUTPUT:

- returns the scalar product between the power sum indexed by ``part1`` and ``part2``

EXAMPLES::

sage: Q.<t> = QQ[]

sage: from sage.combinat.sf.jack import part_scalar_jack

sage: matrix([[part_scalar_jack(p1,p2,t) for p1 in Partitions(4)] for p2 in Partitions(4)])

[ 4*t 0 0 0 0]

[ 0 3*t^2 0 0 0]

[ 0 0 8*t^2 0 0]

[ 0 0 0 4*t^3 0]

[ 0 0 0 0 24*t^4]

"""

if part1 != part2:

return 0

else:

return part1.centralizer_size()*t**len(part1)

#P basis

class JackPolynomials_p(JackPolynomials_generic):

def __init__(self, jack):

r"""

The `P` basis is uni-triangularly related to the monomial basis and

orthogonal with respect to the Jack scalar product.

INPUT:

- ``self`` -- an instance of the Jack `P` basis of the symmetric functions

- ``jack`` -- a family of Jack symmetric function bases

EXAMPLES::

sage: P = SymmetricFunctions(FractionField(QQ['t'])).jack().P()

sage: TestSuite(P).run(skip=['_test_associativity', '_test_distributivity', '_test_prod']) # products are too expensive

sage: TestSuite(P).run(elements = [P.t*P[1,1]+P[2], P[1]+(1+P.t)*P[1,1]])

"""

self._name = "Jack polynomials in the P basis"

self._prefix = "JackP"

self._m_to_self_cache = m_to_p_cache

self._self_to_m_cache = p_to_m_cache

JackPolynomials_generic.__init__(self, jack)

def _m_cache(self, n):

r"""

Computes the change of basis between the Jack polynomials in the `P`

basis and the monomial symmetric functions. This uses Gram-Schmidt

to go to the monomials, and then that matrix is simply inverted.

INPUT:

- ``self`` -- an instance of the Jack `P` basis of the symmetric functions

- ``n`` -- a positive integer indicating the degree

EXAMPLES::

sage: JP = SymmetricFunctions(FractionField(QQ['t'])).jack().P()

sage: l = lambda c: [ (i[0],[j for j in sorted(i[1].items())]) for i in sorted(c.items())]

sage: JP._m_cache(2)

sage: l(JP._self_to_m_cache[2])

[([1, 1], [([1, 1], 1)]), ([2], [([1, 1], 2/(t + 1)), ([2], 1)])]

sage: l(JP._m_to_self_cache[2])

[([1, 1], [([1, 1], 1)]), ([2], [([1, 1], -2/(t + 1)), ([2], 1)])]

sage: JP._m_cache(3)

sage: l(JP._m_to_self_cache[3])

[([1, 1, 1], [([1, 1, 1], 1)]),

([2, 1], [([1, 1, 1], -6/(t + 2)), ([2, 1], 1)]),

([3], [([1, 1, 1], 6/(t^2 + 3*t + 2)), ([2, 1], -3/(2*t + 1)), ([3], 1)])]

sage: l(JP._self_to_m_cache[3])

[([1, 1, 1], [([1, 1, 1], 1)]),

([2, 1], [([1, 1, 1], 6/(t + 2)), ([2, 1], 1)]),

([3], [([1, 1, 1], 6/(2*t^2 + 3*t + 1)), ([2, 1], 3/(2*t + 1)), ([3], 1)])]

"""

if n in self._self_to_m_cache:

return

else:

self._self_to_m_cache[n] = {}

t = QQt.gen()

monomial = sage.combinat.sf.sf.SymmetricFunctions(QQt).monomial()

JP = sage.combinat.sf.sf.SymmetricFunctions(QQt).jack().P()

JP._gram_schmidt(n, monomial, lambda p: part_scalar_jack(p,p,t), \

self._self_to_m_cache[n], upper_triangular=True)

JP._invert_morphism(n, QQt, self._self_to_m_cache, \

self._m_to_self_cache, to_other_function = self._to_m)

def _to_m(self, part):

r"""

Return a function that takes in a partition lambda that returns the

coefficient of lambda in the expansion of self(part) in the

monomial basis.

This assumes that the cache from the Jack polynomials in the `P`

basis to the monomial symmetric functions has already been

computed.

INPUT:

- ``self`` -- an instance of the Jack `P` basis of the symmetric functions

- ``part`` -- a partition

OUTPUT:

- returns a function that accepts a partition and returns the coefficients

of the expansion of the element of ``P(part)`` in the monomial basis

EXAMPLES::

sage: JP = SymmetricFunctions(FractionField(QQ['t'])).jack().P()

sage: JP._m_cache(3)

sage: f = JP._to_m(Partition([2,1]))

sage: [f(part) for part in Partitions(3)]

[0, 1, 6/(t + 2)]

sage: JP.symmetric_function_ring().m()(JP[2,1])

(6/(t+2))*m[1, 1, 1] + m[2, 1]

"""

f = lambda part2: self._self_to_m_cache[sum(part)][part].get(part2, 0)

return f

def _multiply(self, left, right):

r"""

The product of two Jack symmetric functions is done by multiplying the

elements in the monomial basis and then expressing the elements

the basis ``self``.

INPUT:

- ``self`` -- a Jack basis of the symmetric functions

- ``left``, ``right`` -- symmetric function elements

OUTPUT:

- returns the product of ``left`` and ``right`` expanded in the basis ``self``

EXAMPLES::

sage: JP = SymmetricFunctions(FractionField(QQ['t'])).jack().P()

sage: m = JP.symmetric_function_ring().m()

sage: JP([1])^2 # indirect doctest

(2*t/(t+1))*JackP[1, 1] + JackP[2]

sage: m(_)

2*m[1, 1] + m[2]

sage: JP = SymmetricFunctions(QQ).jack(t=2).P()

sage: JP([2,1])^2

125/63*JackP[2, 2, 1, 1] + 25/12*JackP[2, 2, 2] + 25/18*JackP[3, 1, 1, 1] + 12/5*JackP[3, 2, 1] + 4/3*JackP[3, 3] + 4/3*JackP[4, 1, 1] + JackP[4, 2]

sage: m(_)

45*m[1, 1, 1, 1, 1, 1] + 51/2*m[2, 1, 1, 1, 1] + 29/2*m[2, 2, 1, 1] + 33/4*m[2, 2, 2] + 9*m[3, 1, 1, 1] + 5*m[3, 2, 1] + 2*m[3, 3] + 2*m[4, 1, 1] + m[4, 2]

"""

return self( self._m(left)*self._m(right) )

def scalar_jack_basis(self, part1, part2 = None):

r"""

Returns the scalar product of `P(part1)` and `P(part2)`.

This is equation (10.16) of [Mc1995]_ on page 380.

INPUT:

- ``self`` -- an instance of the Jack `P` basis of the symmetric functions

- ``part1`` -- a partition

- ``part2`` -- an optional partition (default : None)

OUTPUT:

- the scalar product between `P(part1)` and `P(part2)` (or itself if `part2` is None)

REFERENCES:

.. [Mc1995] \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.

EXAMPLES::

sage: JP = SymmetricFunctions(FractionField(QQ['t'])).jack().P()

sage: JJ = SymmetricFunctions(FractionField(QQ['t'])).jack().J()

sage: JP.scalar_jack_basis(Partition([2,1]), Partition([1,1,1]))

sage: JP._normalize_coefficients(JP.scalar_jack_basis(Partition([3,2,1]), Partition([3,2,1])))

(12*t^6 + 20*t^5 + 11*t^4 + 2*t^3)/(2*t^3 + 11*t^2 + 20*t + 12)

sage: JJ(JP[3,2,1]).scalar_jack(JP[3,2,1])

(12*t^6 + 20*t^5 + 11*t^4 + 2*t^3)/(2*t^3 + 11*t^2 + 20*t + 12)

With a single argument, takes `part2 = part1`::

sage: JP.scalar_jack_basis(Partition([2,1]), Partition([2,1]))

(2*t^3 + t^2)/(t + 2)

sage: JJ(JP[2,1]).scalar_jack(JP[2,1])

(2*t^3 + t^2)/(t + 2)

"""

if part2 is not None and part1 != part2:

return self.base_ring().zero()

return self.c2(part1) / self.c1(part1)

class Element(JackPolynomials_generic.Element):

def scalar_jack(self, x, t=None):

r"""

The scalar product on the symmetric functions where the power sums

are orthogonal and `\langle p_\mu, p_\mu \rangle = z_\mu t^{length(mu)}`

where the t parameter from the Jack symmetric function family.

INPUT:

- ``self`` -- an element of the Jack `P` basis

- ``x`` -- an element of the `P` basis

EXAMPLES ::

sage: JP = SymmetricFunctions(FractionField(QQ['t'])).jack().P()

sage: l = [JP(p) for p in Partitions(3)]

sage: matrix([[a.scalar_jack(b) for a in l] for b in l])

[ 6*t^3/(2*t^2 + 3*t + 1) 0 0]

[ 0 (2*t^3 + t^2)/(t + 2) 0]

[ 0 0 1/6*t^3 + 1/2*t^2 + 1/3*t]

"""

if isinstance(x, JackPolynomials_p) and t is None:

P = self.parent()

return P._apply_multi_module_morphism(self, x, P.scalar_jack_basis, orthogonal=True)

else:

return JackPolynomials_generic.Element.scalar_jack(self, x, t)

#J basis

class JackPolynomials_j(JackPolynomials_generic):

def __init__(self, jack):

r"""

The `J` basis is a defined as a normalized form of the `P` basis

INPUT:

- ``self`` -- an instance of the Jack `P` basis of the symmetric functions

- ``jack`` -- a family of Jack symmetric function bases

EXAMPLES::

sage: J = SymmetricFunctions(FractionField(QQ['t'])).jack().J()

sage: TestSuite(J).run(skip=['_test_associativity', '_test_distributivity', '_test_prod']) # products are too expensive

sage: TestSuite(J).run(elements = [J.t*J[1,1]+J[2], J[1]+(1+J.t)*J[1,1]]) # long time (3s on sage.math, 2012)

"""

self._name = "Jack polynomials in the J basis"

self._prefix = "JackJ"

JackPolynomials_generic.__init__(self, jack)

# Should be shared with _q (and possibly other bases in Macdo/HL) as BasesByRenormalization

self._P = self._jack.P()

# temporary until Hom(GradedHopfAlgebrasWithBasis) works better

category = sage.categories.all.ModulesWithBasis(self.base_ring())

phi = self.module_morphism(diagonal = self.c1, codomain = self._P, category = category)

# should use module_morphism(on_coeffs = ...) once it exists

self._P.register_coercion(self._P._normalize_morphism(category) * phi)

self .register_coercion(self ._normalize_morphism(category) *~phi)

class Element(JackPolynomials_generic.Element):

pass

#Q basis

class JackPolynomials_q(JackPolynomials_generic):

def __init__(self, jack):

r"""

The `Q` basis is defined as a normalized form of the `P` basis

INPUT:

- ``self`` -- an instance of the Jack `Q` basis of the symmetric functions

- ``jack`` -- a family of Jack symmetric function bases

EXAMPLES::

sage: Q = SymmetricFunctions(FractionField(QQ['t'])).jack().Q()

sage: TestSuite(Q).run(skip=['_test_associativity', '_test_distributivity', '_test_prod']) # products are too expensive

sage: TestSuite(Q).run(elements = [Q.t*Q[1,1]+Q[2], Q[1]+(1+Q.t)*Q[1,1]]) # long time (3s on sage.math, 2012)

"""

self._name = "Jack polynomials in the Q basis"

self._prefix = "JackQ"

JackPolynomials_generic.__init__(self, jack)

# Should be shared with _j (and possibly other bases in Macdo/HL) as BasesByRenormalization

self._P = self._jack.P()

# temporary until Hom(GradedHopfAlgebrasWithBasis) works better

category = sage.categories.all.ModulesWithBasis(self.base_ring())

phi = self._P.module_morphism(diagonal = self._P.scalar_jack_basis, codomain = self, category = category)

self .register_coercion(self ._normalize_morphism(category) * phi)

self._P.register_coercion(self._P._normalize_morphism(category) * ~phi)

class Element(JackPolynomials_generic.Element):

pass

qp_to_h_cache = {}

h_to_qp_cache = {}

class JackPolynomials_qp(JackPolynomials_generic):

def __init__(self, jack):

r"""

The `Qp` basis is the dual basis to the `P` basis with respect to the

standard scalar product

INPUT:

- ``self`` -- an instance of the Jack `Qp` basis of the symmetric functions

- ``jack`` -- a family of Jack symmetric function bases

EXAMPLES::

sage: Qp = SymmetricFunctions(FractionField(QQ['t'])).jack().Qp()

sage: TestSuite(Qp).run(skip=['_test_associativity', '_test_distributivity', '_test_prod']) # products are too expensive

sage: TestSuite(Qp).run(elements = [Qp.t*Qp[1,1]+Qp[2], Qp[1]+(1+Qp.t)*Qp[1,1]]) # long time (3s on sage.math, 2012)

"""

self._name = "Jack polynomials in the Qp basis"

self._prefix = "JackQp"

JackPolynomials_generic.__init__(self, jack)

self._P = self._jack.P()

self._self_to_h_cache = qp_to_h_cache

self._h_to_self_cache = h_to_qp_cache

def _multiply(self, left, right):

r"""

The product of two Jack symmetric functions is done by multiplying the

elements in the monomial basis and then expressing the elements

the basis ``self``.

INPUT:

- ``self`` -- an instance of the Jack `Qp` basis of the symmetric functions

- ``left``, ``right`` -- symmetric function elements

OUTPUT:

- returns the product of ``left`` and ``right`` expanded in the basis ``self``

EXAMPLES::

sage: JQp = SymmetricFunctions(FractionField(QQ['t'])).jack().Qp()

sage: h = JQp.symmetric_function_ring().h()

sage: JQp([1])^2 # indirect doctest

JackQp[1, 1] + (2/(t+1))*JackQp[2]

sage: h(_)

h[1, 1]

sage: JQp = SymmetricFunctions(QQ).jack(t=2).Qp()

sage: h = SymmetricFunctions(QQ).h()

sage: JQp([2,1])^2

JackQp[2, 2, 1, 1] + 2/3*JackQp[2, 2, 2] + 2/3*JackQp[3, 1, 1, 1] + 48/35*JackQp[3, 2, 1] + 28/75*JackQp[3, 3] + 128/225*JackQp[4, 1, 1] + 28/75*JackQp[4, 2]

sage: h(_)

h[2, 2, 1, 1] - 6/5*h[3, 2, 1] + 9/25*h[3, 3]

"""

return self( self._h(left)*self._h(right) )

def _h_cache(self, n):

r"""

Computes the change of basis between the Jack polynomials in the `Qp`

basis and the homogeneous symmetric functions. This uses the coefficients

in the change of basis between the Jack `P` basis and the monomial basis.

INPUT:

- ``self`` -- an instance of the Jack `Qp` basis of the symmetric functions

- ``n`` -- a positive integer indicating the degree

EXAMPLES::

sage: JQp = SymmetricFunctions(FractionField(QQ['t'])).jack().Qp()

sage: l = lambda c: [ (i[0],[j for j in sorted(i[1].items())]) for i in sorted(c.items())]

sage: JQp._h_cache(2)

sage: l(JQp._self_to_h_cache[2])

[([1, 1], [([1, 1], 1), ([2], -2/(t + 1))]), ([2], [([2], 1)])]

sage: l(JQp._h_to_self_cache[2])

[([1, 1], [([1, 1], 1), ([2], 2/(t + 1))]), ([2], [([2], 1)])]

sage: JQp._h_cache(3)

sage: l(JQp._h_to_self_cache[3])

[([1, 1, 1], [([1, 1, 1], 1), ([2, 1], 6/(t + 2)), ([3], 6/(2*t^2 + 3*t + 1))]), ([2, 1], [([2, 1], 1), ([3], 3/(2*t + 1))]), ([3], [([3], 1)])]

sage: l(JQp._self_to_h_cache[3])

[([1, 1, 1], [([1, 1, 1], 1), ([2, 1], -6/(t + 2)), ([3], 6/(t^2 + 3*t + 2))]), ([2, 1], [([2, 1], 1), ([3], -3/(2*t + 1))]), ([3], [([3], 1)])]

"""

if n in self._self_to_h_cache:

return

else:

self._self_to_h_cache[n] = {}

self._h_to_self_cache[n] = {}

self._P._m_cache(n)

from_cache_1 = self._P._self_to_m_cache[n]

to_cache_1 = self._self_to_h_cache[n]

from_cache_2 = self._P._m_to_self_cache[n]

to_cache_2 = self._h_to_self_cache[n]

for mu in from_cache_1:

for la in from_cache_1[mu]:

if not la in to_cache_1:

to_cache_1[la] = {}

to_cache_2[la] = {}

to_cache_2[la][mu] = from_cache_1[mu][la]

to_cache_1[la][mu] = from_cache_2[mu][la]

def _self_to_h( self, x ):

r"""

Isomorphism from self to the homogeneous basis

INPUT:

- ``self`` -- a Jack `Qp` basis of the symmetric functions

- ``x`` -- an element of the Jack `Qp` basis

OUTPUT:

- an element of the homogeneous basis equivalent to ``x``

EXAMPLES ::

sage: Sym = SymmetricFunctions(QQ)

sage: JQp = Sym.jack(t=2).Qp()

sage: h = Sym.homogeneous()

sage: JQp._self_to_h(JQp[2,1])

h[2, 1] - 3/5*h[3]

This is for internal use only. Please use instead::

sage: h(JQp[2,1])

h[2, 1] - 3/5*h[3]

"""

return self._h._from_cache(x, self._h_cache, self._self_to_h_cache, t = self.t)

def _h_to_self( self, x ):

r"""

Isomorphism from the homogeneous basis into ``self``

INPUT:

- ``self`` -- a Jack `Qp` basis of the symmetric functions

- ``x`` -- element of the homogeneous basis

OUTPUT:

- an element of the Jack `Qp` basis equivalent to ``x``

EXAMPLES ::

sage: Sym = SymmetricFunctions(QQ)

sage: JQp = Sym.jack(t=2).Qp()

sage: h = Sym.homogeneous()

sage: JQp._h_to_self(h[2,1])

JackQp[2, 1] + 3/5*JackQp[3]

This is for internal use only. Please use instead::

sage: JQp(h[2,1])

JackQp[2, 1] + 3/5*JackQp[3]

"""

return self._from_cache(x, self._h_cache, self._h_to_self_cache, t = self.t)

def coproduct_by_coercion( self, elt ):

r"""

Returns the coproduct of the element ``elt`` by coercion to the Schur basis.

INPUT:

- ``elt`` -- an instance of the ``Qp`` basis

OUTPUT:

- The coproduct acting on ``elt``, the result is an element of the

tensor squared of the ``Qp`` symmetric function basis

EXAMPLES::

sage: Sym = SymmetricFunctions(QQ['t'].fraction_field())

sage: JQp = Sym.jack().Qp()

sage: JQp[2,2].coproduct() #indirect doctest

JackQp[] # JackQp[2, 2] + (2*t/(t+1))*JackQp[1] # JackQp[2, 1] + JackQp[1, 1] # JackQp[1, 1] + ((4*t^3+8*t^2)/(2*t^3+5*t^2+4*t+1))*JackQp[2] # JackQp[2] + (2*t/(t+1))*JackQp[2, 1] # JackQp[1] + JackQp[2, 2] # JackQp[]

"""

h = elt.parent().realization_of().h()

parent = elt.parent()

from sage.categories.tensor import tensor

cfunc = lambda x, y: tensor([parent(x), parent(y)])

cprod = h(elt).coproduct().apply_multilinear_morphism( cfunc )

normalize = lambda c: normalize_coefficients( parent, c )

return cprod.parent().sum(normalize(coeff)*tensor([parent(x), parent(y)])

for ((x,y), coeff) in cprod)

class Element(JackPolynomials_generic.Element):

pass

#Zonal polynomials ( =P(at t=2) )

class SymmetricFunctionAlgebra_zonal(sfa.SymmetricFunctionAlgebra_generic):

def __init__(self, Sym):

r"""

Returns the algebra of zonal polynomials.

INPUT:

- ``self`` -- a zonal basis of the symmetric functions

- ``Sym`` -- a ring of the symmetric functions

EXAMPLES ::

sage: Z = SymmetricFunctions(QQ).zonal()

sage: Z([2])^2

64/45*Z[2, 2] + 16/21*Z[3, 1] + Z[4]

sage: Z = SymmetricFunctions(QQ).zonal()

sage: TestSuite(Z).run(skip=['_test_associativity', '_test_distributivity', '_test_prod']) # products are too expensive

sage: TestSuite(Z).run(elements = [Z[1,1]+Z[2], Z[1]+2*Z[1,1]])

"""

self._sym = Sym

self._jack = self._sym.jack(t=2)

self._P = self._jack.P()

#self._m_to_self_cache = {} Now that we compute Jacks once, there is a global cache

#self._self_to_m_cache = {} and we don't need to compute it separately for zonals

sfa.SymmetricFunctionAlgebra_generic.__init__(self, self._sym,

prefix="Z", basis_name="zonal")

category = sage.categories.all.ModulesWithBasis(self._sym.base_ring())

self .register_coercion(SetMorphism(Hom(self._P, self, category), self.sum_of_terms))

self._P.register_coercion(SetMorphism(Hom(self, self._P, category), self._P.sum_of_terms))

def _multiply(self, left, right):

r"""

The product of two zonal symmetric functions is done by multiplying the

elements in the monomial basis and then expressing the elements

the basis ``self``.

INPUT:

- ``self`` -- a zonal basis of the symmetric functions

- ``left``, ``right`` -- symmetric function elements

OUTPUT:

- returns the product of ``left`` and ``right`` expanded in the basis ``self``

EXAMPLES ::

sage: Sym = SymmetricFunctions(QQ)

sage: Z = Sym.zonal()

sage: JP = Sym.jack(t=1).P()

sage: Z([2])*Z([3]) # indirect doctest

192/175*Z[3, 2] + 32/45*Z[4, 1] + Z[5]

sage: Z([2])*JP([2])

10/27*Z[2, 1, 1] + 64/45*Z[2, 2] + 23/21*Z[3, 1] + Z[4]

sage: JP = Sym.jack(t=2).P()

sage: Z([2])*JP([2])

64/45*Z[2, 2] + 16/21*Z[3, 1] + Z[4]

"""

return self( self._P(left)*self._P(right) )

class Element(sfa.SymmetricFunctionAlgebra_generic.Element):

def scalar_zonal(self, x):

r"""

The zonal scalar product has the power sum basis and the zonal

symmetric functions are orthogonal. In particular,

`\langle p_\mu, p_\mu \rangle = z_\mu 2^{length(\mu)}`.

INPUT:

- ``self`` -- an element of the zonal basis

- ``x`` -- an element of the symmetric function

OUTPUT:

- the scalar product between ``self`` and ``x``

EXAMPLES ::

sage: Sym = SymmetricFunctions(QQ)

sage: Z = Sym.zonal()

sage: parts = Partitions(3).list()

sage: matrix([[Z(a).scalar_zonal(Z(b)) for a in parts] for b in parts])

[16/5 0 0]

[ 0 5 0]

[ 0 0 4]

sage: p = Z.symmetric_function_ring().power()

sage: matrix([[Z(p(a)).scalar_zonal(p(b)) for a in parts] for b in parts])

[ 6 0 0]

[ 0 8 0]

[ 0 0 48]

"""

P = self.parent()._P

return P(self).scalar_jack(P(x),2)

# Backward compatibility for unpickling

from sage.structure.sage_object import register_unpickle_override

register_unpickle_override('sage.combinat.sf.jack', 'JackPolynomial_qp', JackPolynomials_qp.Element)

register_unpickle_override('sage.combinat.sf.jack', 'JackPolynomial_j', JackPolynomials_j.Element)

register_unpickle_override('sage.combinat.sf.jack', 'JackPolynomial_p', JackPolynomials_p.Element)

register_unpickle_override('sage.combinat.sf.jack', 'JackPolynomial_q', JackPolynomials_q.Element)

#register_unpickle_override('sage.combinat.sf.jack', 'SymmetricFunctionAlgebra_zonal', SymmetricFunctionAlgebra_zonal.Element)

Coverage for local/lib/python2.7/site-packages/sage/combinat/sf/jack.py : 64%

225 statements 145 run 80 missing 0 excluded