Non-symmetric Macdonald Polynomials

class sage.combinat.sf.ns_macdonald.AugmentedLatticeDiagramFilling(l, pi=None)

Bases: CombinatorialObject

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a == loads(dumps(a))
True
sage: pi = Permutation([2,3,1]).to_permutation_group_element()
sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]],pi)
sage: a == loads(dumps(a))
True

are_attacking(i, j, ii, jj)

Return True if the boxes (i,j) and (ii,jj) in self are attacking.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: all( a.are_attacking(i,j,ii,jj) for (i,j),(ii,jj) in a.attacking_boxes())
True
sage: a.are_attacking(1,1,3,2)
False

attacking_boxes()

Return a list of pairs of boxes in self that are attacking.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.attacking_boxes()[:5]
[((1, 1), (2, 1)),
 ((1, 1), (3, 1)),
 ((1, 1), (6, 1)),
 ((1, 1), (2, 0)),
 ((1, 1), (3, 0))]

boxes()

Return a list of the coordinates of the boxes of self, including the ‘basement row’.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.boxes()
[(1, 1),
 (1, 2),
 (2, 1),
 (3, 1),
 (3, 2),
 (3, 3),
 (6, 1),
 (6, 2),
 (1, 0),
 (2, 0),
 (3, 0),
 (4, 0),
 (5, 0),
 (6, 0)]

coeff(q, t)

Return the coefficient in front of self in the HHL formula for the expansion of the non-symmetric Macdonald polynomial E(self.shape()).

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: q,t = var('q,t')                                                      # needs sage.symbolic
sage: a.coeff(q,t)                                                          # needs sage.symbolic
(t - 1)^4/((q^2*t^3 - 1)^2*(q*t^2 - 1)^2)

coeff_integral(q, t)

Return the coefficient in front of self in the HHL formula for the expansion of the integral non-symmetric Macdonald polynomial E(self.shape())

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: q,t = var('q,t')                                                      # needs sage.symbolic
sage: a.coeff_integral(q,t)                                                 # needs sage.symbolic
(q^2*t^3 - 1)^2*(q*t^2 - 1)^2*(t - 1)^4

coinv()

Return self’s co-inversion statistic.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.coinv()
2

descents()

Return a list of the descents of self.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.descents()
[(1, 2), (3, 2)]

inv()

Return self’s inversion statistic.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.inv()
15

inversions()

Return a list of the inversions of self.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.inversions()[:5]
[((6, 2), (3, 2)),
 ((1, 2), (6, 1)),
 ((1, 2), (3, 1)),
 ((1, 2), (2, 1)),
 ((6, 1), (3, 1))]
sage: len(a.inversions())
25

is_non_attacking()

Return True if self is non-attacking.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.is_non_attacking()
True
sage: a = AugmentedLatticeDiagramFilling([[1, 1, 1], [2, 3], [3]])
sage: a.is_non_attacking()
False
sage: a = AugmentedLatticeDiagramFilling([[2,2],[1]])
sage: a.is_non_attacking()
False
sage: pi = Permutation([2,1]).to_permutation_group_element()
sage: a = AugmentedLatticeDiagramFilling([[2,2],[1]],pi)
sage: a.is_non_attacking()
True

maj()

Return the major index of self.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.maj()
3

permuted_filling(sigma)

EXAMPLES:

sage: pi=Permutation([2,1,4,3]).to_permutation_group_element()
sage: fill=[[2],[1,2,3],[],[3,1]]
sage: AugmentedLatticeDiagramFilling(fill).permuted_filling(pi)
[[2, 1], [1, 2, 1, 4], [4], [3, 4, 2]]

reading_order()

Return a list of coordinates of the boxes in self, starting from the top right, and reading from right to left.

Note that this includes the ‘basement row’ of self.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.reading_order()
[(3, 3),
 (6, 2),
 (3, 2),
 (1, 2),
 (6, 1),
 (3, 1),
 (2, 1),
 (1, 1),
 (6, 0),
 (5, 0),
 (4, 0),
 (3, 0),
 (2, 0),
 (1, 0)]

reading_word()

Return the reading word of self, obtained by reading the boxes entries of self from right to left, starting in the upper right.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.reading_word()
word: 25465321

shape()

Return the shape of self.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.shape()
[2, 1, 3, 0, 0, 2]

weight()

Return the weight of self.

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.weight()
[1, 2, 1, 1, 2, 1]

sage.combinat.sf.ns_macdonald.E(mu, q=None, t=None, pi=None)

Return the non-symmetric Macdonald polynomial in type A corresponding to a shape mu, with basement permuted according to pi.

Note that if both \(q\) and \(t\) are specified, then they must have the same parent.

REFERENCE:

• J. Haglund, M. Haiman, N. Loehr. A combinatorial formula for non-symmetric Macdonald polynomials. arXiv math/0601693v3.

See also

NonSymmetricMacdonaldPolynomials for a type free implementation where the polynomials are constructed recursively by the application of intertwining operators.

EXAMPLES:

sage: from sage.combinat.sf.ns_macdonald import E
sage: E([0,0,0])
1
sage: E([1,0,0])
x0
sage: E([0,1,0])
(t - 1)/(q*t^2 - 1)*x0 + x1
sage: E([0,0,1])
(t - 1)/(q*t - 1)*x0 + (t - 1)/(q*t - 1)*x1 + x2
sage: E([1,1,0])
x0*x1
sage: E([1,0,1])
(t - 1)/(q*t^2 - 1)*x0*x1 + x0*x2
sage: E([0,1,1])
(t - 1)/(q*t - 1)*x0*x1 + (t - 1)/(q*t - 1)*x0*x2 + x1*x2
sage: E([2,0,0])
x0^2 + (q*t - q)/(q*t - 1)*x0*x1 + (q*t - q)/(q*t - 1)*x0*x2
sage: E([0,2,0])
(t - 1)/(q^2*t^2 - 1)*x0^2 + (q^2*t^3 - q^2*t^2 + q*t^2 - 2*q*t + q - t + 1)/(q^3*t^3 - q^2*t^2 - q*t + 1)*x0*x1 + x1^2 + (q*t^2 - 2*q*t + q)/(q^3*t^3 - q^2*t^2 - q*t + 1)*x0*x2 + (q*t - q)/(q*t - 1)*x1*x2

sage.combinat.sf.ns_macdonald.E_integral(mu, q=None, t=None, pi=None)

Return the integral form for the non-symmetric Macdonald polynomial in type A corresponding to a shape mu.

Note that if both q and t are specified, then they must have the same parent.

REFERENCE:

• J. Haglund, M. Haiman, N. Loehr. A combinatorial formula for non-symmetric Macdonald polynomials. arXiv math/0601693v3.

EXAMPLES:

sage: from sage.combinat.sf.ns_macdonald import E_integral
sage: E_integral([0,0,0])
1
sage: E_integral([1,0,0])
(-t + 1)*x0
sage: E_integral([0,1,0])
(-q*t^2 + 1)*x0 + (-t + 1)*x1
sage: E_integral([0,0,1])
(-q*t + 1)*x0 + (-q*t + 1)*x1 + (-t + 1)*x2
sage: E_integral([1,1,0])
(t^2 - 2*t + 1)*x0*x1
sage: E_integral([1,0,1])
(q*t^3 - q*t^2 - t + 1)*x0*x1 + (t^2 - 2*t + 1)*x0*x2
sage: E_integral([0,1,1])
(q^2*t^3 + q*t^4 - q*t^3 - q*t^2 - q*t - t^2 + t + 1)*x0*x1 + (q*t^2 - q*t - t + 1)*x0*x2 + (t^2 - 2*t + 1)*x1*x2
sage: E_integral([2,0,0])
(t^2 - 2*t + 1)*x0^2 + (q^2*t^2 - q^2*t - q*t + q)*x0*x1 + (q^2*t^2 - q^2*t - q*t + q)*x0*x2
sage: E_integral([0,2,0])
(q^2*t^3 - q^2*t^2 - t + 1)*x0^2 + (q^4*t^3 - q^3*t^2 - q^2*t + q*t^2 - q*t + q - t + 1)*x0*x1 + (t^2 - 2*t + 1)*x1^2 + (q^4*t^3 - q^3*t^2 - q^2*t + q)*x0*x2 + (q^2*t^2 - q^2*t - q*t + q)*x1*x2

sage.combinat.sf.ns_macdonald.Ht(mu, q=None, t=None, pi=None)

Return the symmetric Macdonald polynomial using the Haiman, Haglund, and Loehr formula.

Note that if both \(q\) and \(t\) are specified, then they must have the same parent.

REFERENCE:

• J. Haglund, M. Haiman, N. Loehr. A combinatorial formula for non-symmetric Macdonald polynomials. arXiv math/0601693v3.

EXAMPLES:

sage: from sage.combinat.sf.ns_macdonald import Ht
sage: HHt = SymmetricFunctions(QQ['q','t'].fraction_field()).macdonald().Ht()
sage: Ht([0,0,1])
x0 + x1 + x2
sage: HHt([1]).expand(3)
x0 + x1 + x2
sage: Ht([0,0,2])
x0^2 + (q + 1)*x0*x1 + x1^2 + (q + 1)*x0*x2 + (q + 1)*x1*x2 + x2^2
sage: HHt([2]).expand(3)
x0^2 + (q + 1)*x0*x1 + x1^2 + (q + 1)*x0*x2 + (q + 1)*x1*x2 + x2^2

class sage.combinat.sf.ns_macdonald.LatticeDiagram(l, copy=True)

Bases: CombinatorialObject

a(i, j)

Return the length of the arm of the box (i,j) in self.

EXAMPLES:

sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.a(5,2)
3

arm(i, j)

Return the arm of the box (i,j) in self.

EXAMPLES:

sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.arm(5,2)
[(1, 2), (3, 2), (8, 1)]

arm_left(i, j)

Return the left arm of the box (i,j) in self.

EXAMPLES:

sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.arm_left(5,2)
[(1, 2), (3, 2)]

arm_right(i, j)

Return the right arm of the box (i,j) in self.

EXAMPLES:

sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.arm_right(5,2)
[(8, 1)]

boxes()

EXAMPLES:

sage: a = LatticeDiagram([3,0,2])
sage: a.boxes()
[(1, 1), (1, 2), (1, 3), (3, 1), (3, 2)]
sage: a = LatticeDiagram([2, 1, 3, 0, 0, 2])
sage: a.boxes()
[(1, 1), (1, 2), (2, 1), (3, 1), (3, 2), (3, 3), (6, 1), (6, 2)]

boxes_same_and_lower_right(ii, jj)

Return a list of the boxes of self that are in row jj but not identical with (ii, jj), or lie in the row jj - 1 (the row directly below jj; this might be the basement) and strictly to the right of (ii, jj).

EXAMPLES:

sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a = a.shape()
sage: a.boxes_same_and_lower_right(1,1)
[(2, 1), (3, 1), (6, 1), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0)]
sage: a.boxes_same_and_lower_right(1,2)
[(3, 2), (6, 2), (2, 1), (3, 1), (6, 1)]
sage: a.boxes_same_and_lower_right(3,3)
[(6, 2)]
sage: a.boxes_same_and_lower_right(2,3)
[(3, 3), (3, 2), (6, 2)]

flip()

Return the flip of self, where flip is defined as follows. Let r = max(self). Then self.flip()[i] = r - self[i].

EXAMPLES:

sage: a = LatticeDiagram([3,0,2])
sage: a.flip()
[0, 3, 1]

l(i, j)

Return self[i] - j.

EXAMPLES:

sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.l(5,2)
1

leg(i, j)

Return the leg of the box (i,j) in self.

EXAMPLES:

sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.leg(5,2)
[(5, 3)]

size()

Return the number of boxes in self.

EXAMPLES:

sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.size()
22

class sage.combinat.sf.ns_macdonald.NonattackingBacktracker(shape, pi=None)

Bases: GenericBacktracker

EXAMPLES:

sage: from sage.combinat.sf.ns_macdonald import NonattackingBacktracker
sage: n = NonattackingBacktracker(LatticeDiagram([0,1,2]))
sage: n._ending_position
(3, 2)
sage: n._initial_state
(2, 1)

get_next_pos(ii, jj)

EXAMPLES:

sage: from sage.combinat.sf.ns_macdonald import NonattackingBacktracker
sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: n = NonattackingBacktracker(a.shape())
sage: n.get_next_pos(1, 1)
(2, 1)
sage: n.get_next_pos(6, 1)
(1, 2)
sage: n = NonattackingBacktracker(LatticeDiagram([2,2,2]))
sage: n.get_next_pos(3, 1)
(1, 2)

sage.combinat.sf.ns_macdonald.NonattackingFillings(shape, pi=None)

Returning the finite set of nonattacking fillings of a given shape.

EXAMPLES:

sage: NonattackingFillings([0,1,2])
Nonattacking fillings of [0, 1, 2]
sage: NonattackingFillings([0,1,2]).list()
[[[1], [2, 1], [3, 2, 1]],
 [[1], [2, 1], [3, 2, 2]],
 [[1], [2, 1], [3, 2, 3]],
 [[1], [2, 1], [3, 3, 1]],
 [[1], [2, 1], [3, 3, 2]],
 [[1], [2, 1], [3, 3, 3]],
 [[1], [2, 2], [3, 1, 1]],
 [[1], [2, 2], [3, 1, 2]],
 [[1], [2, 2], [3, 1, 3]],
 [[1], [2, 2], [3, 3, 1]],
 [[1], [2, 2], [3, 3, 2]],
 [[1], [2, 2], [3, 3, 3]]]

class sage.combinat.sf.ns_macdonald.NonattackingFillings_shape(shape, pi=None)

Bases: Parent, UniqueRepresentation

EXAMPLES:

sage: n = NonattackingFillings([0,1,2])
sage: n == loads(dumps(n))
True

flip()

Return the nonattacking fillings of the flipped shape.

EXAMPLES:

sage: NonattackingFillings([0,1,2]).flip()
Nonattacking fillings of [2, 1, 0]