18.31 Hall-Littlewood Polynomials

Module: sage.combinat.sf.hall_littlewood

Hall-Littlewood Polynomials

Module-level Functions

HallLittlewoodP( R, [t=None])

Returns the algebra of symmetric functions in Hall-Littlewood P basis. This is the same as the HL basis in John Stembridge's SF examples file.

If t is not specified, then the base ring will be obtained by making the univariate polynomial ring over R with the variable t and taking its fraction field.

sage: HallLittlewoodP(QQ)
Hall-Littlewood polynomials in the P basis over Fraction Field of
Univariate Polynomial Ring in t over Rational Field
sage: HallLittlewoodP(QQ, t=-1)
Hall-Littlewood polynomials in the P basis with t=-1 over Rational Field
sage: HLP = HallLittlewoodP(QQ)
sage: s = SFASchur(HLP.base_ring())
sage: s(HLP([2,1]))
(-t^2-t)*s[1, 1, 1] + s[2, 1]

The Hall-Littlewood polynomials in the P basis at t = 0 are the Schur functions.

sage: HLP = HallLittlewoodP(QQ,t=0)
sage: s = SFASchur(HLP.base_ring())
sage: s(HLP([2,1])) == s([2,1])
True

The Hall-Littlewood polynomials in the P basis at t = 1 are the monomial symmetric functions.

sage: HLP = HallLittlewoodP(QQ,t=1)
sage: m = SFAMonomial(HLP.base_ring())
sage: m(HLP([2,2,1])) == m([2,2,1])
True

HallLittlewoodQ( R, [t=None])

Returns the algebra of symmetric functions in Hall-Littlewood Q basis. This is the same as the Q basis in John Stembridge's SF examples file.

If t is not specified, then the base ring will be obtained by making the univariate polynomial ring over R with the variable t and taking its fraction field.

sage: HallLittlewoodQ(QQ)
Hall-Littlewood polynomials in the Q basis over Fraction Field of
Univariate Polynomial Ring in t over Rational Field
sage: HallLittlewoodQ(QQ, t=-1)
Hall-Littlewood polynomials in the Q basis with t=-1 over Rational Field

HallLittlewoodQp( R, [t=None])

Returns the algebra of symmetric functions in Hall-Littlewood Qp basis. This is dual to the Hall-Littlewood P basis with respect to the standard scalar product.

If t is not specified, then the base ring will be obtained by making the univariate polynomial ring over R with the variable t and taking its fraction field.

sage: HallLittlewoodQp(QQ)
Hall-Littlewood polynomials in the Qp basis over Fraction Field of
Univariate Polynomial Ring in t over Rational Field
sage: HallLittlewoodQp(QQ, t=-1)
Hall-Littlewood polynomials in the Qp basis with t=-1 over Rational Field

Class: HallLittlewood_generic

class HallLittlewood_generic
HallLittlewood_generic( self, R, [t=None])

TESTS:

sage: HallLittlewoodP(QQ)
Hall-Littlewood polynomials in the P basis over Fraction Field of
Univariate Polynomial Ring in t over Rational Field
sage: HallLittlewoodP(QQ,t=2)
Hall-Littlewood polynomials in the P basis with t=2 over Rational Field

Functions: transition_matrix

transition_matrix( self, basis, n)

Returns the transitions matrix between self and basis for the homogenous component of degree n.

sage: HLP = HallLittlewoodP(QQ)
sage: s   = SFASchur(HLP.base_ring())
sage: HLP.transition_matrix(s, 4)
[             1             -t              0            t^2          
-t^3]
[             0              1             -t             -t      t^3 +
t^2]
[             0              0              1             -t           
t^3]
[             0              0              0              1 -t^3 - t^2 -
t]
[             0              0              0              0             
1]
sage: HLQ = HallLittlewoodQ(QQ)
sage: HLQ.transition_matrix(s,3)
[                        -t + 1                        t^2 - t             
-t^3 + t^2]
[                             0                  t^2 - 2*t + 1          
-t^4 + t^3 + t^2 - t]
[                             0                              0 -t^6 + t^5 +
t^4 - t^2 - t + 1]
sage: HLQp = HallLittlewoodQp(QQ)
sage: HLQp.transition_matrix(s,3)
[      1       0       0]
[      t       1       0]
[    t^3 t^2 + t       1]

Special Functions: __init__

Class: HallLittlewood_p

class HallLittlewood_p
HallLittlewood_p( self, R, [t=None])

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

Special Functions: __init__,$ \,$ _coerce_start,$ \,$ _multiply,$ \,$ _q_to_self,$ \,$ _s_cache,$ \,$ _s_to_self

_coerce_start( self, x)

Coerce things into the Hall-Littlewood P basis.

1) Hall-Littlewood polynomials in the Q basis 2) Hall-Littlewood polynomials in the Qp basis (via the Schurs) 3) Classical symmetric functions

sage: HLP  = HallLittlewoodP(QQ)
sage: HLQ  = HallLittlewoodQ(QQ)
sage: HLQp = HallLittlewoodQp(QQ)
sage: s = SFASchur(HLP.base_ring()); p = SFAPower(HLP.base_ring()) 
sage: HLP(HLQ([2])) # indirect doctest
(-t+1)*P[2]
sage: HLP(HLQp([2]))
t*P[1, 1] + P[2]
sage: HLP(s([2]))
t*P[1, 1] + P[2]
sage: HLP(p([2]))
(t-1)*P[1, 1] + P[2]

_multiply( self, left, right)

Convert to the Schur basis, do the multiplication there, and convert back to the P basis.

sage: HLP = HallLittlewoodP(QQ)
sage: HLP([2])^2 # indirect doctest
(t+1)*P[2, 2] + (-t+1)*P[3, 1] + P[4]

_q_to_self( self, m)

Returns the scalar coefficient on self(m) when converting from the Q basis to the P basis. Note that this assumes that m is a Partition object.

sage: HLP  = HallLittlewoodP(QQ)
sage: HLP._q_to_self(Partition([2,1]))
t^2 - 2*t + 1

_s_cache( self, n)

Computes the change of basis between the P polynomials and the Schur functions for partitions of size n.

Uses the fact that the transformation matrix is upper-triangular in order to obtain the inverse transformation.

sage: P = HallLittlewoodP(QQ)
sage: P._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(P._s_to_self_cache[2])
[([1, 1], [([1, 1], 1)]), ([2], [([1, 1], t), ([2], 1)])]
sage: l(P._self_to_s_cache[2])
[([1, 1], [([1, 1], 1)]), ([2], [([1, 1], -t), ([2], 1)])]

_s_to_self( self, part)

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

sage: P = HallLittlewoodP(QQ)
sage: f21 = P._s_to_self(Partition([2,1]))
sage: [f21(p) for p in Partitions(3)]
[0, 1, t^2 + t]

Class: HallLittlewood_q

class HallLittlewood_q
HallLittlewood_q( self, R, [t=None])

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

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

_coerce_start( self, x)

sage: HLP  = HallLittlewoodP(QQ)
sage: HLQ  = HallLittlewoodQ(QQ)
sage: HLQp = HallLittlewoodQp(QQ)
sage: s = SFASchur(HLP.base_ring()); p = SFAPower(HLP.base_ring())
sage: HLQ( HLP([2,1]) + HLP([3]) )
(1/(t^2-2*t+1))*Q[2, 1] + (1/(-t+1))*Q[3]
sage: HLQ(HLQp([2])) # indirect doctest
(-t/(-t^3+t^2+t-1))*Q[1, 1] + (1/(-t+1))*Q[2]
sage: HLQ(s([2]))
(-t/(-t^3+t^2+t-1))*Q[1, 1] + (1/(-t+1))*Q[2]
sage: HLQ(p([2]))
(-1/(-t^2+1))*Q[1, 1] + (1/(-t+1))*Q[2]

_multiply( self, left, right)

Converts to the P basis, does the multiplication there, and converts back to the Q basis.

sage: HLQ = HallLittlewoodQ(QQ)
sage: HLQ([2])^2 # indirect doctest
Q[2, 2] + (-t+1)*Q[3, 1] + (-t+1)*Q[4]

_p_to_self( self, m)

Returns the scalar coefficient on self(m) when converting from the Q basis to the P basis. Note that this assumes that m is a Partition object.

sage: HLQ  = HallLittlewoodQ(QQ)
sage: HLQ._p_to_self(Partition([2,1]))
1/(t^2 - 2*t + 1)

Class: HallLittlewood_qp

class HallLittlewood_qp
HallLittlewood_qp( self, R, [t=None])

sage: Qp = HallLittlewoodQp(QQ)
sage: Qp == loads(dumps(Qp))
True

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

_coerce_start( self, x)

Coerce things into the Hall-Littlewood Qp basis.

1) Hall-Littlewood polynomials in the Q basis (via the Schurs) 2) Hall-Littlewood polynomials in the P basis (via the Schurs) 3) Symmetric Functions

sage: HLP  = HallLittlewoodP(QQ)
sage: HLQ  = HallLittlewoodQ(QQ)
sage: HLQp = HallLittlewoodQp(QQ)
sage: s = SFASchur(HLP.base_ring()); p = SFAPower(HLP.base_ring())
sage: HLQp(HLP([2])) # indirect doctest
-t*Qp[1, 1] + (t^2+1)*Qp[2]
sage: HLQp(HLQ([2]))
(t^2-t)*Qp[1, 1] + (-t^3+t^2-t+1)*Qp[2]
sage: HLQp(s([2]))
Qp[2]
sage: HLQp(p([2]))
-Qp[1, 1] + (t+1)*Qp[2]

_multiply( self, left, right)

Converts the Hall-Littlewood polynomial in the Qp basis to a Schur function, performs the multiplication there, and converts it back to the Qp basis.

sage: HLQp = HallLittlewoodQp(QQ)
sage: HLQp([2])^2 # indirect doctest
Qp[2, 2] + (-t+1)*Qp[3, 1] + (-t+1)*Qp[4]

_s_cache( self, n)

Computes the change of basis between the Qp polynomials and the Schur functions for partitions of size n.

Uses the fact that the transformation matrix is lower-triangular in order to obtain the inverse transformation.

sage: Qp = HallLittlewoodQp(QQ)
sage: Qp._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(Qp._s_to_self_cache[2])
[([1, 1], [([1, 1], 1), ([2], -t)]), ([2], [([2], 1)])]
sage: l(Qp._self_to_s_cache[2])
[([1, 1], [([1, 1], 1), ([2], t)]), ([2], [([2], 1)])]

_to_s( self, part)

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

sage: Qp = HallLittlewoodQp(QQ)
sage: f21 = Qp._to_s(Partition([2,1]))
sage: [f21(p) for p in Partitions(3)]
[t, 1, 0]

Class: HallLittlewoodElement_generic

class HallLittlewoodElement_generic

Functions: expand,$ \,$ scalar,$ \,$ scalar_hl

expand( self, n, [alphabet=x])

Expands the symmetric function as a symmetric polynomial in n variables.

sage: HLP  = HallLittlewoodP(QQ)
sage: HLQ  = HallLittlewoodQ(QQ)
sage: HLQp = HallLittlewoodQp(QQ)
sage: HLP([2]).expand(2)
x0^2 + (-t + 1)*x0*x1 + x1^2
sage: HLQ([2]).expand(2)
(-t + 1)*x0^2 + (t^2 - 2*t + 1)*x0*x1 + (-t + 1)*x1^2
sage: HLQp([2]).expand(2)
x0^2 + x0*x1 + x1^2

scalar( self, x)

Returns standard scalar product between self and s.

This is the default implementation that converts both self and x into Schur functions and performs the scalar product that basis.

sage: HLP  = HallLittlewoodP(QQ)
sage: HLQ  = HallLittlewoodQ(QQ)
sage: HLQp = HallLittlewoodQp(QQ)
sage: HLP([2]).scalar(HLQp([2]))
1
sage: HLP([2]).scalar(HLQp([1,1]))
0

scalar_hl( self, x, [t=None])

Returns the standard Hall-Littlewood scalar product of self and x.

sage: HLP  = HallLittlewoodP(QQ)
sage: HLQ  = HallLittlewoodQ(QQ)
sage: HLQp = HallLittlewoodQp(QQ)
sage: HLP([2]).scalar_hl(HLQ([2]))
1
sage: HLP([2]).scalar_hl(HLQ([1,1]))
0

Class: HallLittlewoodElement_p

class HallLittlewoodElement_p

Class: HallLittlewoodElement_q

class HallLittlewoodElement_q

Class: HallLittlewoodElement_qp

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