Bases: sage.combinat.combinat.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
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
Returns 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))]
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)]
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')
sage: a.coeff(q,t)
(t - 1)^4/((q^2*t^3 - 1)^2*(q*t^2 - 1)^2)
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')
sage: a.coeff_integral(q,t)
(q^2*t^3 - 1)^2*(q*t^2 - 1)^2*(t - 1)^4
Return self‘s co-inversion statistic.
EXAMPLES:
sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.coinv()
2
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)]
Return self‘s inversion statistic.
EXAMPLES:
sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.inv()
15
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
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
Return the major index of self.
EXAMPLES:
sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
sage: a.maj()
3
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]]
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)]
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
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]
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]
Returns the non-symmetric Macdonald polynomial in type A corresponding to a shape mu, with basement permuted according to pi.
Note that if both and
are specified, then they must have
the same parent.
REFERENCE:
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
Returns 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:
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
Returns the symmetric Macdonald polynomial using the Haiman, Haglund, and Loehr formula.
Note that if both and
are specified, then they must have the
same parent.
REFERENCE:
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
Bases: sage.combinat.combinat.CombinatorialObject
CombinatorialObject provides a thin wrapper around a list. The main differences are that __setitem__ is disabled so that CombinatorialObjects are shallowly immutable, and the intention is that they are semantically immutable.
Because of this, CombinatorialObjects provide a __hash__ function which computes the hash of the string representation of a list and the hash of its parent’s class. Thus, each CombinatorialObject should have a unique string representation.
INPUT:
list
EXAMPLES:
sage: c = CombinatorialObject([1,2,3])
sage: c == loads(dumps(c))
True
sage: c._list
[1, 2, 3]
sage: c._hash is None
True
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
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)]
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)]
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)]
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)]
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)]
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]
Return self[i] - j.
EXAMPLES:
sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.l(5,2)
1
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)]
Return the number of boxes in self.
EXAMPLES:
sage: a = LatticeDiagram([3,1,2,4,3,0,4,2,3])
sage: a.size()
22
Bases: sage.combinat.backtrack.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)
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)
Returning the combinatorial class 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]]]
Bases: sage.combinat.combinat.CombinatorialClass
EXAMPLES:
sage: n = NonattackingFillings([0,1,2])
sage: n == loads(dumps(n))
True
Returns the nonattacking fillings of the the flipped shape.
EXAMPLES:
sage: NonattackingFillings([0,1,2]).flip()
Nonattacking fillings of [2, 1, 0]