Module: sage.combinat.tableau
Tableaux
Module-level Functions
[p=None], [mu=None]) |
Returns the combinatorial class of semistandard tableaux.
If p is specified and is a partition, then it returns the class of semistandard tableaux of shape p (and max entry sum(p))
If p is specified and is an integer, it returns the class of semistandard tableaux of size p.
If mu is also specified, then it returns the class of semistandard tableaux with evaluation/content mu.
sage: SST = SemistandardTableaux([2,1]); SST Semistandard tableaux of shape [2, 1] sage: SST.list() [[[1, 1], [2]], [[1, 1], [3]], [[1, 2], [2]], [[1, 2], [3]], [[1, 3], [2]], [[1, 3], [3]], [[2, 2], [3]], [[2, 3], [3]]]
sage: SST = SemistandardTableaux(3); SST Semistandard tableaux of size 3 sage: SST.list() [[[1, 1, 1]], [[1, 1, 2]], [[1, 1, 3]], [[1, 2, 2]], [[1, 2, 3]], [[1, 3, 3]], [[2, 2, 2]], [[2, 2, 3]], [[2, 3, 3]], [[3, 3, 3]], [[1, 1], [2]], [[1, 1], [3]], [[1, 2], [2]], [[1, 2], [3]], [[1, 3], [2]], [[1, 3], [3]], [[2, 2], [3]], [[2, 3], [3]], [[1], [2], [3]]]
[n=None]) |
Returns the combinatorial class of standard tableaux. If n is specified abd is an integer, then it returns the combinatorial class of all standard tableaux of size n. If n is a partition, then it returns the class of all standard tableaux of shape n.
sage: ST = StandardTableaux(3); ST Standard tableaux of size 3 sage: ST.first() [[1, 2, 3]] sage: ST.last() [[1], [2], [3]] sage: ST.count() 4 sage: ST.list() [[[1, 2, 3]], [[1, 3], [2]], [[1, 2], [3]], [[1], [2], [3]]]
sage: ST = StandardTableaux([2,2]); ST Standard tableaux of shape [2, 2] sage: ST.first() [[1, 3], [2, 4]] sage: ST.last() [[1, 2], [3, 4]] sage: ST.count() 2 sage: ST.list() [[[1, 3], [2, 4]], [[1, 2], [3, 4]]]
t) |
Returns the tableau object corresponding to t.
Note that Sage uses the English convention for partitions and tableaux.
sage: t = Tableau([[1,2,3],[4,5]]); t [[1, 2, 3], [4, 5]] sage: t.shape() [3, 2] sage: t.is_standard() True
[n=None]) |
Returns the combinatorial class of tableaux. If n is specified, then it returns the combinatoiral class of all tableaux of size n.
sage: T = Tableaux(); T Tableaux sage: [[1,2],[3,4]] in T True sage: [[1,2],[3]] in T True sage: [1,2,3] in T False
sage: T = Tableaux(4); T Tableaux of size 4 sage: [[1,2],[3,4]] in T True sage: [[1,2],[3]] in T False sage: [1,2,3] in T False
chain) |
Returns a semistandard tableau from a chain of partitions.
sage: from sage.combinat.tableau import from_chain sage: from_chain([[], [2], [2, 1], [3, 2, 1]]) [[1, 1, 3], [2, 3], [3]]
shape, w) |
Returns a tableau from a shape and word.
sage: from sage.combinat.tableau import from_shape_and_word sage: t = Tableau([[1, 3], [2], [4]]) sage: shape = t.shape(); shape [2, 1, 1] sage: word = t.to_word(); word [4, 2, 1, 3] sage: from_shape_and_word(shape, word) [[1, 3], [2], [4]]
Class: SemistandardTableaux_all
self) |
TESTS:
sage: SST = SemistandardTableaux() sage: SST == loads(dumps(SST)) True
Functions: list
self) |
TESTS:
sage: SemistandardTableaux().list() Traceback (most recent call last): ... NotImplementedError
Special Functions: __contains__,
__init__
self, x) |
TESTS:
sage: [[1,2],[1]] in SemistandardTableaux() False sage: SST = SemistandardTableaux() sage: all([st in SST for st in StandardTableaux(4)]) True sage: [[1,1],[2]] in SemistandardTableaux() True
Class: SemistandardTableaux_n
self, n) |
TESTS:
sage: SST = SemistandardTableaux(3) sage: SST == loads(dumps(SST)) True
Functions: count,
iterator
self) |
sage: SemistandardTableaux(3).count() 19 sage: SemistandardTableaux(4).count() 116 sage: ns = range(1, 6) sage: ssts = [ SemistandardTableaux(n) for n in ns ] sage: all([sst.count() == len(sst.list()) for sst in ssts]) True
self) |
sage: SemistandardTableaux(2).list() [[[1, 1]], [[1, 2]], [[2, 2]], [[1], [2]]] sage: SemistandardTableaux(3).list() [[[1, 1, 1]], [[1, 1, 2]], [[1, 1, 3]], [[1, 2, 2]], [[1, 2, 3]], [[1, 3, 3]], [[2, 2, 2]], [[2, 2, 3]], [[2, 3, 3]], [[3, 3, 3]], [[1, 1], [2]], [[1, 1], [3]], [[1, 2], [2]], [[1, 2], [3]], [[1, 3], [2]], [[1, 3], [3]], [[2, 2], [3]], [[2, 3], [3]], [[1], [2], [3]]]
Special Functions: __contains__,
__init__,
__repr__
self, x) |
sage: [[1,2],[3,3]] in SemistandardTableaux(3) False sage: [[1,2],[3,3]] in SemistandardTableaux(4) True sage: SST = SemistandardTableaux(4) sage: all([sst in SST for sst in SST]) True
self) |
TESTS:
sage: repr(SemistandardTableaux(3)) 'Semistandard tableaux of size 3'
Class: SemistandardTableaux_nmu
self, n, mu) |
TESTS:
sage: SST = SemistandardTableaux(3, [2,1]) sage: SST == loads(dumps(SST)) True
Functions: count,
iterator
self) |
sage: SemistandardTableaux(3, [2,1]).count() 2 sage: SemistandardTableaux(4, [2,2]).count() 3
self) |
sage: SemistandardTableaux(3, [2,1]).list() [[[1, 1, 2]], [[1, 1], [2]]] sage: SemistandardTableaux(4, [2,2]).list() [[[1, 1, 2, 2]], [[1, 1, 2], [2]], [[1, 1], [2, 2]]]
Special Functions: __contains__,
__init__,
__repr__
self, x) |
TESTS:
sage: SST = SemistandardTableaux(6, [2,2,2]) sage: all([sst in SST for sst in SST]) True sage: all([sst in SST for sst in SemistandardTableaux([3,2,1],[2,2,2])]) True
self) |
TESTS:
sage: repr(SemistandardTableaux(3, [2,1])) 'Semistandard tableaux of size 3 and evaluation [2, 1]'
Class: SemistandardTableaux_p
self, p) |
TESTS:
sage: SST = SemistandardTableaux([2,1]) sage: SST == loads(dumps(SST)) True
Functions: count,
iterator
self) |
sage: SemistandardTableaux([2,1]).count() 8 sage: SemistandardTableaux([2,2,1]).count() 75 sage: s = SFASchur(QQ) sage: s([2,2,1]).expand(5)(1,1,1,1,1) 75 sage: SemistandardTableaux([5]).count() 126 sage: SemistandardTableaux([3,2,1]).count() 896
self) |
An iterator for the semistandard partitions of shape p.
sage: SemistandardTableaux([3]).list() [[[1, 1, 1]], [[1, 1, 2]], [[1, 1, 3]], [[1, 2, 2]], [[1, 2, 3]], [[1, 3, 3]], [[2, 2, 2]], [[2, 2, 3]], [[2, 3, 3]], [[3, 3, 3]]] sage: SemistandardTableaux([2,1]).list() [[[1, 1], [2]], [[1, 1], [3]], [[1, 2], [2]], [[1, 2], [3]], [[1, 3], [2]], [[1, 3], [3]], [[2, 2], [3]], [[2, 3], [3]]] sage: SemistandardTableaux([1,1,1]).list() [[[1], [2], [3]]]
Special Functions: __contains__,
__init__,
__repr__
self, x) |
sage: SST = SemistandardTableaux([2,1]) sage: all([sst in SST for sst in SST]) True sage: len(filter(lambda x: x in SST, SemistandardTableaux(3))) 8 sage: SST.count() 8
self) |
TESTS:
sage: repr(SemistandardTableaux([2,1])) 'Semistandard tableaux of shape [2, 1]'
Class: SemistandardTableaux_pmu
self, p, mu) |
TESTS:
sage: SST = SemistandardTableaux([2,1], [2,1]) sage: SST == loads(dumps(SST)) True
Functions: count,
list
self) |
sage: SemistandardTableaux([2,2], [2, 1, 1]).count() 1 sage: SemistandardTableaux([2,2,2], [2, 2, 1,1]).count() 1 sage: SemistandardTableaux([2,2,2], [2, 2, 2]).count() 1 sage: SemistandardTableaux([3,2,1], [2, 2, 2]).count() 2
self) |
sage: SemistandardTableaux([2,2], [2, 1, 1]).list() [[[1, 1], [2, 3]]] sage: SemistandardTableaux([2,2,2], [2, 2, 1,1]).list() [[[1, 1], [2, 2], [3, 4]]] sage: SemistandardTableaux([2,2,2], [2, 2, 2]).list() [[[1, 1], [2, 2], [3, 3]]] sage: SemistandardTableaux([3,2,1], [2, 2, 2]).list() [[[1, 1, 2], [2, 3], [3]], [[1, 1, 3], [2, 2], [3]]]
Special Functions: __contains__,
__init__,
__repr__
self, x) |
sage: SST = SemistandardTableaux([2,1], [2,1]) sage: all([sst in SST for sst in SST]) True sage: len(filter(lambda x: x in SST, SemistandardTableaux(3))) 1 sage: SST.count() 1
self) |
TESTS:
sage: repr(SemistandardTableaux([2,1],[2,1])) 'Semistandard tableaux of shape [2, 1] and evaluation [2, 1]'
Class: StandardTableaux_all
self) |
TESTS:
sage: ST = StandardTableaux() sage: ST == loads(dumps(ST)) True
Functions: list
self) |
TESTS:
sage: StandardTableaux().list() Traceback (most recent call last): ... NotImplementedError
Special Functions: __contains__,
__init__,
__repr__
self, x) |
sage: [[1,1],[2,3]] in StandardTableaux() False sage: [[1,2],[3,4]] in StandardTableaux() True sage: [[1,3],[2,4]] in StandardTableaux() True
self) |
TESTS:
sage: repr(StandardTableaux()) 'Standard tableaux'
Class: StandardTableaux_n
self, n) |
TESTS:
sage: ST = StandardTableaux(3) sage: ST == loads(dumps(ST)) True
Functions: count,
iterator
self) |
sage: StandardTableaux(3).count() 4 sage: ns = [1,2,3,4,5,6] sage: sts = [StandardTableaux(n) for n in ns] sage: all([st.count() == len(st.list()) for st in sts]) True
self) |
sage: StandardTableaux(1).list() [[[1]]] sage: StandardTableaux(2).list() [[[1, 2]], [[1], [2]]] sage: StandardTableaux(3).list() [[[1, 2, 3]], [[1, 3], [2]], [[1, 2], [3]], [[1], [2], [3]]] sage: StandardTableaux(4).list() [[[1, 2, 3, 4]], [[1, 3, 4], [2]], [[1, 2, 4], [3]], [[1, 2, 3], [4]], [[1, 3], [2, 4]], [[1, 2], [3, 4]], [[1, 4], [2], [3]], [[1, 3], [2], [4]], [[1, 2], [3], [4]], [[1], [2], [3], [4]]]
Special Functions: __contains__,
__init__,
__repr__
self, x) |
TESTS:
sage: ST3 = StandardTableaux(3) sage: all([st in ST3 for st in ST3]) True sage: ST4 = StandardTableaux(4) sage: filter(lambda x: x in ST3, ST4) []
self) |
TESTS:
sage: repr(StandardTableaux(3)) 'Standard tableaux of size 3'
Class: StandardTableaux_partition
self, p) |
TESTS:
sage: ST = StandardTableaux([2,1,1]) sage: ST == loads(dumps(ST)) True
Functions: count,
iterator,
list,
random_element
self) |
Returns the number of standard Young tableaux associated with a partition pi
A formula for the number of Young tableaux associated with a given partition. In each box, write the sum of one plus the number of boxes horizontally to the right and vertically below the box (the hook length). The number of tableaux is then n! divided by the product of all hook lengths.
For example, consider the partition [3,2,1] of 6 with Ferrers Diagram * * * * * * When we fill in the boxes with the hook lengths, we obtain 5 3 1 3 1 1 The hook length formula returns 6!/(5*3*1*3*1*1) = 16.
sage: StandardTableaux([3,2,1]).count() 16 sage: StandardTableaux([2,2]).count() 2 sage: StandardTableaux([5]).count() 1 sage: StandardTableaux([6,5,5,3]).count() 6651216
REFERENCES: http://mathworld.wolfram.com/HookLengthFormula.html
self) |
An iterator for the standard Young tableaux associated to the partition pi.
sage: [p for p in StandardTableaux([2,2])] [[[1, 3], [2, 4]], [[1, 2], [3, 4]]] sage: [p for p in StandardTableaux([3,2])] [[[1, 3, 5], [2, 4]], [[1, 2, 5], [3, 4]], [[1, 3, 4], [2, 5]], [[1, 2, 4], [3, 5]], [[1, 2, 3], [4, 5]]]
self) |
Returns a list of the standard Young tableau associated with a partition p.
sage: StandardTableaux([2,2]).list() [[[1, 3], [2, 4]], [[1, 2], [3, 4]]] sage: StandardTableaux([5]).list() [[[1, 2, 3, 4, 5]]] sage: StandardTableaux([3,2,1]).list() [[[1, 4, 6], [2, 5], [3]], [[1, 3, 6], [2, 5], [4]], [[1, 2, 6], [3, 5], [4]], [[1, 3, 6], [2, 4], [5]], [[1, 2, 6], [3, 4], [5]], [[1, 4, 5], [2, 6], [3]], [[1, 3, 5], [2, 6], [4]], [[1, 2, 5], [3, 6], [4]], [[1, 3, 4], [2, 6], [5]], [[1, 2, 4], [3, 6], [5]], [[1, 2, 3], [4, 6], [5]], [[1, 3, 5], [2, 4], [6]], [[1, 2, 5], [3, 4], [6]], [[1, 3, 4], [2, 5], [6]], [[1, 2, 4], [3, 5], [6]], [[1, 2, 3], [4, 5], [6]]]
self) |
Returns a random standard tableau of shape p using the Green-Nijenhuis-Wilf Algorithm.
sage: StandardTableaux([2,2]).random_element() [[1, 2], [3, 4]]
Special Functions: __contains__,
__init__,
__repr__
self, x) |
sage: ST = StandardTableaux([2,1,1]) sage: all([st in ST for st in ST]) True sage: len(filter(lambda x: x in ST, StandardTableaux(4))) 3 sage: ST.count() 3
self) |
TESTS:
sage: repr(StandardTableaux([2,1,1])) 'Standard tableaux of shape [2, 1, 1]'
Class: Tableau_class
self, t) |
TESTS:
sage: t = Tableau([[1,2],[3,4]]) sage: t == loads(dumps(t)) True
Functions: anti_restrict,
atom,
attacking_pairs,
boxes,
bump,
bump_multiply,
charge,
cocharge,
column_stabilizer,
conjugate,
corners,
descents,
down,
down_list,
entry,
evaluation,
height,
insert_word,
inversion_number,
inversions,
is_rectangular,
is_standard,
k_weight,
katabolism,
katabolism_projector,
katabolism_sequence,
lambda_katabolism,
last_letter_lequal,
major_index,
pp,
promotion,
promotion_inverse,
promotion_operator,
raise_action_from_words,
reduced_lambda_katabolism,
restrict,
rotate_180,
row_stabilizer,
schensted_insert,
shape,
size,
slide_multiply,
socle,
symmetric_group_action_on_values,
to_chain,
to_list,
to_permutation,
to_word,
to_word_by_column,
to_word_by_row,
up,
up_list,
vertical_flip,
weight
self, n) |
Returns the skew tableau formed by removing all of the boxes from self that are filled with a number less than
sage: t = Tableau([[1,2,3],[4,5]]); t [[1, 2, 3], [4, 5]] sage: t.anti_restrict(1) [[None, 2, 3], [4, 5]] sage: t.anti_restrict(2) [[None, None, 3], [4, 5]] sage: t.anti_restrict(3) [[None, None, None], [4, 5]] sage: t.anti_restrict(4) [[None, None, None], [None, 5]]
self) |
sage: Tableau([[1,2],[3,4]]).atom() [2, 2] sage: Tableau([[1,2,3],[4,5],[6]]).atom() [3, 2, 1]
self) |
Returns a list of the attacking pairs of self. An pair of boxes (c, d) is said to be attacking if one of the following conditions hold:
1) c and d lie in the same row with c to the west of d 2) c is in the row immediately to the south of d and c lies strictly east of d.
sage: t = Tableau([[1,2,3],[2,5]]) sage: t.attacking_pairs() [((0, 0), (0, 1)), ((0, 0), (0, 2)), ((0, 1), (0, 2)), ((1, 0), (1, 1)), ((1, 1), (0, 0))]
self) |
Returns a list of the coordinates of the boxes of self.
sage: Tableau([[1,2],[3,4]]).boxes() [(0, 0), (0, 1), (1, 0), (1, 1)]
self, x) |
Schensted's row-bumping (or row-insertion) algorithm.
sage: t = Tableau([[1,2],[3]]) sage: t.bump(1) [[1, 1], [2], [3]] sage: t [[1, 2], [3]] sage: t.bump(2) [[1, 2, 2], [3]] sage: t.bump(3) [[1, 2, 3], [3]] sage: t [[1, 2], [3]] sage: t = Tableau([[1,2,2,3],[2,3,5,5],[4,4,6],[5,6]]) sage: t.bump(2) [[1, 2, 2, 2], [2, 3, 3, 5], [4, 4, 5], [5, 6, 6]]
left, right) |
Multiply two tableaux using Schensted's bump.
This product makes the set of tableaux into an associative monoid. The empty tableaux is the unit in this monoid.
Fulton, William. 'Young Tableaux' p11-12
sage: t = Tableau([[1,2,2,3],[2,3,5,5],[4,4,6],[5,6]]) sage: t2 = Tableau([[1,2],[3]]) sage: t.bump_multiply(t2) [[1, 1, 2, 2, 3], [2, 2, 3, 5], [3, 4, 5], [4, 6, 6], [5]]
self) |
EXAPMLES:
sage: Tableau([[1,1],[2,2],[3]]).charge() 0 sage: Tableau([[1,1,3],[2,2]]).charge() 1 sage: Tableau([[1,1,2],[2],[3]]).charge() 1 sage: Tableau([[1,1,2],[2,3]]).charge() 2 sage: Tableau([[1,1,2,3],[2]]).charge() 2 sage: Tableau([[1,1,2,2],[3]]).charge() 3 sage: Tableau([[1,1,2,2,3]]).charge() 4
self) |
EXAPMLES:
sage: Tableau([[1,1],[2,2],[3]]).cocharge() 4 sage: Tableau([[1,1,3],[2,2]]).cocharge() 3 sage: Tableau([[1,1,2],[2],[3]]).cocharge() 2 sage: Tableau([[1,1,2],[2,3]]).cocharge() 2 sage: Tableau([[1,1,2,3],[2]]).cocharge() 1 sage: Tableau([[1,1,2,2],[3]]).cocharge() 1 sage: Tableau([[1,1,2,2,3]]).cocharge() 0
self) |
Return the PermutationGroup corresponding to the column stabilizer of self.
sage: cs = Tableau([[1,2,3],[4,5]]).column_stabilizer() sage: cs.order() == factorial(2)*factorial(2) True sage: PermutationGroupElement([(1,3,2),(4,5)]) in cs False sage: PermutationGroupElement([(1,4)]) in cs True
self) |
Returns the conjugate of the tableau t.
sage: Tableau([[1,2],[3,4]]).conjugate() [[1, 3], [2, 4]]
self) |
Returns the corners of the tableau t.
sage: Tableau([[1, 4, 6], [2, 5], [3]]).corners() [[0, 2], [1, 1], [2, 0]] sage: Tableau([[1, 3], [2, 4]]).corners() [[1, 1]]
self) |
Returns a list of the boxes (i,j) such that self[i][j] > self[i-1][j].
sage: Tableau( [[1,4],[2,3]] ).descents() [(1, 0)] sage: Tableau( [[1,2],[3,4]] ).descents() [(1, 0), (1, 1)]
self) |
An iterator for all the tableaux that can be obtained from self by removing a box. Note that this iterates just over a single tableaux.
sage: t = Tableau([[1,2],[3]]) sage: [x for x in t.down()] [[[1, 2]]]
self) |
Returns a list of all the tableaux that can be obtained from self by removing a box. Note that this is just a single tableaux.
sage: t = Tableau([[1,2],[3]]) sage: t.down_list() [[[1, 2]]]
self, box) |
Returns the entry of box in self. Box is a tuple (i,j) of coordinates.
sage: t = Tableau([[1,2],[3,4]]) sage: t.entry( (0,0) ) 1 sage: t.entry( (1,1) ) 4
self) |
Returns the evaluation of the word from tableau t.
sage: Tableau([[1,2],[3,4]]).evaluation() [1, 1, 1, 1]
self) |
Returns the height of the tableau.
sage: Tableau([[1,2,3],[4,5]]).height() 2 sage: Tableau([[1,2,3]]).height() 1 sage: Tableau([]).height() 0
self, w, [left=False]) |
sage: t0 = Tableau([]) sage: w = [1,1,2,3,3,3,3] sage: t0.insert_word(w) [[1, 1, 2, 3, 3, 3, 3]] sage: t0.insert_word(w,left=True) [[1, 1, 2, 3, 3, 3, 3]] sage: w.reverse() sage: t0.insert_word(w) [[1, 1, 3, 3], [2, 3], [3]] sage: t0.insert_word(w,left=True) [[1, 1, 3, 3], [2, 3], [3]]
self) |
Returns the inversion number of self.
The inversion number is defined to be the number of inversion of self minus the sum of the arm lengths of the descents of self.
sage: t = Tableau([[1,2,3],[2,5]]) sage: t.inversion_number() 0
self) |
Returns a list of the inversions of self. An inversion is an attacking pair (c,d) such that the entry of c in self is greater than the entry of d.
sage: t = Tableau([[1,2,3],[2,5]]) sage: t.inversions() [((1, 1), (0, 0))]
self) |
Returns True if the tableau t is rectangular and False otherwise.
sage: Tableau([[1,2],[3,4]]).is_rectangular() True sage: Tableau([[1,2,3],[4,5],[6]]).is_rectangular() False
self) |
Returns True if t is a standard tableau and False otherwise.
sage: Tableau([[1, 3], [2, 4]]).is_standard() True sage: Tableau([[1, 2], [2, 4]]).is_standard() False sage: Tableau([[2, 3], [2, 4]]).is_standard() False sage: Tableau([[5, 3], [2, 4]]).is_standard() False
self, k) |
Returns the k-weight of self.
sage: Tableau([[1,2],[2,3]]).k_weight(1) [1, 1, 1] sage: Tableau([[1,2],[2,3]]).k_weight(2) [1, 2, 1] sage: t = Tableau([[1,1,1,2,5],[2,3,6],[3],[4]]) sage: t.k_weight(1) [2, 1, 1, 1, 1, 1] sage: t.k_weight(2) [3, 2, 2, 1, 1, 1] sage: t.k_weight(3) [3, 1, 2, 1, 1, 1] sage: t.k_weight(4) [3, 2, 2, 1, 1, 1] sage: t.k_weight(5) [3, 2, 2, 1, 1, 1]
self) |
sage: Tableau([]).katabolism() [] sage: Tableau([[1,2,3,4,5]]).katabolism() [[1, 2, 3, 4, 5]] sage: Tableau([[1,1,3,3],[2,3],[3]]).katabolism() [[1, 1, 2, 3, 3, 3], [3]] sage: Tableau([[1, 1, 2, 3, 3, 3], [3]]).katabolism() [[1, 1, 2, 3, 3, 3, 3]]
self, parts) |
sage: t = Tableau([[1,1,3,3],[2,3],[3]]) sage: t.katabolism_projector([[4,2,1]]) [[1, 1, 3, 3], [2, 3], [3]] sage: t.katabolism_projector([[1]]) [] sage: t.katabolism_projector([[2,1],[1]]) [] sage: t.katabolism_projector([[1,1],[4,1]]) [[1, 1, 3, 3], [2, 3], [3]]
self) |
sage: t = Tableau([[1,2,3,4,5,6,8],[7,9]]) sage: t.katabolism_sequence() [[[1, 2, 3, 4, 5, 6, 8], [7, 9]], [[1, 2, 3, 4, 5, 6, 7, 9], [8]], [[1, 2, 3, 4, 5, 6, 7, 8], [9]], [[1, 2, 3, 4, 5, 6, 7, 8, 9]]]
self, part) |
sage: t = Tableau([[1,1,3,3],[2,3],[3]]) sage: t.lambda_katabolism([]) [[1, 1, 3, 3], [2, 3], [3]] sage: t.lambda_katabolism([1]) [[1, 2, 3, 3, 3], [3]] sage: t.lambda_katabolism([1,1]) [[1, 3, 3, 3], [3]] sage: t.lambda_katabolism([2,1]) [[3, 3, 3, 3]] sage: t.lambda_katabolism([4,2,1]) [] sage: t.lambda_katabolism([5,1]) [[3, 3]] sage: t.lambda_katabolism([4,1]) [[3, 3]]
self, tab2) |
Returns True if self is less than or equal to tab2 in the last letter ordering.
sage: st = StandardTableaux([3,2]) sage: f = lambda b: 1 if b else 0 sage: matrix( [ [ f(t1.last_letter_lequal(t2)) for t2 in st] for t1 in st] ) [1 1 1 1 1] [0 1 1 1 1] [0 0 1 1 1] [0 0 0 1 1] [0 0 0 0 1]
self) |
Returns the major index of self. The major index is defined to be the sum of the number of descents of self and the sum of their legs.
EXAMPLES
sage: Tableau( [[1,4],[2,3]] ).major_index() 1 sage: Tableau( [[1,2],[3,4]] ).major_index() 2
self) |
Returns a pretty print string of the tableau.
sage: Tableau([[1,2,3],[3,4],[5]]).pp() 1 2 3 3 4 5
self, n) |
Promotion operator defined on rectangular tableaux using jeu de taquin
sage: t = Tableau([[1,2],[3,3]]) sage: t.promotion(2) [[1, 1], [2, 3]] sage: t = Tableau([[1,1,1],[2,2,3],[3,4,4]]) sage: t.promotion(3) [[1, 1, 2], [2, 2, 3], [3, 4, 4]] sage: t = Tableau([[1,2],[2]]) sage: t.promotion(3) Traceback (most recent call last): ... ValueError: Tableau is not rectangular
self, n) |
Inverse promotion operator defined on rectangular tableaux using jeu de taquin
sage: t = Tableau([[1,2],[3,3]]) sage: t.promotion_inverse(2) [[1, 2], [2, 3]] sage: t = Tableau([[1,2],[2,3]]) sage: t.promotion_inverse(2) [[1, 1], [2, 3]]
self, i) |
sage: t = Tableau([[1,2],[3]]) sage: t.promotion_operator(1) [[[1, 2], [3], [4]], [[1, 2], [3, 4]], [[1, 2, 4], [3]]] sage: t.promotion_operator(2) [[[1, 1], [2, 3], [4]], [[1, 1, 2], [3], [4]], [[1, 1, 4], [2, 3]], [[1, 1, 2, 4], [3]]] sage: Tableau([[1]]).promotion_operator(2) [[[1, 1], [2]], [[1, 1, 2]]] sage: Tableau([[1,1],[2]]).promotion_operator(3) [[[1, 1, 1], [2, 2], [3]], [[1, 1, 1, 2], [2], [3]], [[1, 1, 1, 3], [2, 2]], [[1, 1, 1, 2, 3], [2]]]
TESTS:
sage: Tableau([]).promotion_operator(2) [[[1, 1]]] sage: Tableau([]).promotion_operator(1) [[[1]]]
self, f) |
sage: from sage.combinat.word import symmetric_group_action_on_values sage: import functools sage: t = Tableau([[1,1,3,3],[2,3],[3]]) sage: f = functools.partial(t.raise_action_from_words, symmetric_group_action_on_values) sage: f([1,2,3]) [[1, 1, 3, 3], [2, 3], [3]] sage: f([3,2,1]) [[1, 1, 1, 1], [2, 3], [3]] sage: f([1,3,2]) [[1, 1, 2, 2], [2, 2], [3]]
self, part) |
sage: t = Tableau([[1,1,3,3],[2,3],[3]]) sage: t.reduced_lambda_katabolism([]) [[1, 1, 3, 3], [2, 3], [3]] sage: t.reduced_lambda_katabolism([1]) [[1, 2, 3, 3, 3], [3]] sage: t.reduced_lambda_katabolism([1,1]) [[1, 3, 3, 3], [3]] sage: t.reduced_lambda_katabolism([2,1]) [[3, 3, 3, 3]] sage: t.reduced_lambda_katabolism([4,2,1]) [] sage: t.reduced_lambda_katabolism([5,1]) 0 sage: t.reduced_lambda_katabolism([4,1]) 0
self, n) |
Returns the restriction of the standard tableau to n.
sage: Tableau([[1,2],[3],[4]]).restrict(3) [[1, 2], [3]] sage: Tableau([[1,2],[3],[4]]).restrict(2) [[1, 2]] sage: Tableau([[1,1],[2]]).restrict(1) [[1, 1]]
self) |
Returns the tableau obtained by rotating t by 180 degrees.
sage: Tableau([[1,2],[3,4]]).rotate_180() [[4, 3], [2, 1]]
self) |
Return the PermutationGroup corresponding to the row stabilizer of self.
sage: rs = Tableau([[1,2,3],[4,5]]).row_stabilizer() sage: rs.order() == factorial(3)*factorial(2) True sage: PermutationGroupElement([(1,3,2),(4,5)]) in rs True sage: PermutationGroupElement([(1,4)]) in rs False sage: rs = Tableau([[1],[2],[3]]).row_stabilizer() sage: rs.order() 1
self, i, [left=False]) |
sage: t = Tableau([[3,5],[7]]) sage: t.schensted_insert(8) [[3, 5, 8], [7]] sage: t.schensted_insert(8, left=True) [[3, 5], [7], [8]]
self) |
Returns the shape of a tableau t.
sage: Tableau([[1,2,3],[4,5],[6]]).shape() [3, 2, 1]
self) |
Returns the size of the shape of the tableau t.
sage: Tableau([[1, 4, 6], [2, 5], [3]]).size() 6 sage: Tableau([[1, 3], [2, 4]]).size() 4
left, right) |
Multiply two tableaux using jeu de taquin.
This product makes the set of tableaux into an associative monoid. The empty tableaux is the unit in this monoid.
Fulton, William. 'Young Tableaux' p15
sage: t = Tableau([[1,2,2,3],[2,3,5,5],[4,4,6],[5,6]]) sage: t2 = Tableau([[1,2],[3]]) sage: t.slide_multiply(t2) [[1, 1, 2, 2, 3], [2, 2, 3, 5], [3, 4, 5], [4, 6, 6], [5]]
self) |
sage: Tableau([[1,2],[3,4]]).socle() 2 sage: Tableau([[1,2,3,4]]).socle() 4
self, perm) |
sage: t = Tableau([[1,1,3,3],[2,3],[3]]) sage: t.symmetric_group_action_on_values([1,2,3]) [[1, 1, 3, 3], [2, 3], [3]] sage: t.symmetric_group_action_on_values([3,2,1]) [[1, 1, 1, 1], [2, 3], [3]] sage: t.symmetric_group_action_on_values([1,3,2]) [[1, 1, 2, 2], [2, 2], [3]]
self) |
Returns the chain of partitions corresponding to the (semi)standard tableau.
sage: Tableau([[1,2],[3],[4]]).to_chain() [[], [1], [2], [2, 1], [2, 1, 1]] sage: Tableau([[1,1],[2]]).to_chain() [[], [2], [2, 1]] sage: Tableau([[1,1],[3]]).to_chain() [[], [2], [2], [2, 1]] sage: Tableau([]).to_chain() [[]]
self) |
sage: t = Tableau([[1,2],[3,4]]) sage: l = t.to_list(); l [[1, 2], [3, 4]] sage: l[0][0] = 2 sage: t [[1, 2], [3, 4]]
self) |
Returns a permutation with the entries of self obtained by reading self in the reading order.
sage: Tableau([[1,2],[3,4]]).to_permutation() [3, 4, 1, 2]
self) |
An alias for to_word_by_row.
sage: Tableau([[1,2],[3,4]]).to_word() [3, 4, 1, 2] sage: Tableau([[1, 4, 6], [2, 5], [3]]).to_word() [3, 2, 5, 1, 4, 6]
self) |
Returns the word obtained from a column reading of the tableau t.
sage: Tableau([[1,2],[3,4]]).to_word_by_column() [3, 1, 4, 2] sage: Tableau([[1, 4, 6], [2, 5], [3]]).to_word_by_column() [3, 2, 1, 5, 4, 6]
self) |
Returns a word obtained from a row reading of the tableau t.
sage: Tableau([[1,2],[3,4]]).to_word_by_row() [3, 4, 1, 2] sage: Tableau([[1, 4, 6], [2, 5], [3]]).to_word_by_row() [3, 2, 5, 1, 4, 6]
self) |
An iterator for all the tableaux that can be obtained from self by adding a box.
sage: t = Tableau([[1,2]]) sage: [x for x in t.up()] [[[1, 2, 3]], [[1, 2], [3]]]
self) |
Returns a list of all the tableaux that can be obtained from self by adding a box.
sage: t = Tableau([[1,2]]) sage: t.up_list() [[[1, 2, 3]], [[1, 2], [3]]]
self) |
Returns the tableau obtained by vertically flipping the tableau t. This only works for rectangular tableau.
sage: Tableau([[1,2],[3,4]]).vertical_flip() [[3, 4], [1, 2]]
self) |
Returns the evaluation of the word from tableau t.
sage: Tableau([[1,2],[3,4]]).evaluation() [1, 1, 1, 1]
Special Functions: __div__,
__init__,
_heights,
_latex_,
_left_schensted_insert,
_right_schensted_insert,
_tex_from_array
self, t) |
Returns the skew partition self/t.
sage: t = Tableau([[1,2,3],[3,4],[5]]) sage: t/[1,1] [[None, 2, 3], [None, 4], [5]] sage: t/[3,1] [[None, None, None], [None, 4], [5]]
self) |
sage: Tableau([[1,2,3,4],[5,6],[7],[8]])._heights() [1, 3, 4, 4] sage: Tableau([])._heights() [] sage: Tableau([[1]])._heights() [1] sage: Tableau([[1,2]])._heights() [1, 1] sage: Tableau([[1,2],[3],[4]])._heights() [1, 3]
self) |
Returns a LaTeX version of self.
sage: latex(Tableau([[1,2],[3,4]])) {\def\lr#1#2#3{\multicolumn{1}{#1@{\hspace{.6ex}}c@{\hspace{.6ex}}#2}{\rais ebox{-.3ex}{$#3$}}} \raisebox{-.6ex}{$\begin{array}[b]{cc} \cline{1-1}\cline{2-2}% \lr{|}{|}{1}\&\lr{|}{|}{2}\\ % \cline{1-1}\cline{2-2}% \lr{|}{|}{3}\&\lr{|}{|}{4}\\ % \cline{1-1}\cline{2-2}% \end{array}$} }
self, letter) |
sage: t = Tableau([[3,5],[7]]) sage: t._left_schensted_insert(8) [[3, 5], [7], [8]] sage: t._left_schensted_insert(6) [[3, 5], [6, 7]] sage: t._left_schensted_insert(2) [[2, 3, 5], [7]]
self, letter) |
sage: t = Tableau([[3,5],[7]]) sage: t._right_schensted_insert(8) [[3, 5, 8], [7]] sage: t._right_schensted_insert(2) [[2, 5], [3], [7]] sage: t = Tableau([[3,8],[7]]) sage: t._right_schensted_insert(6) [[3, 6], [7, 8]]
self) |
sage: print Tableau([[1,2],[3,4]])._tex_from_array() {\def\lr#1#2#3{\multicolumn{1}{#1@{\hspace{.6ex}}c@{\hspace{.6ex}}#2}{\rais ebox{-.3ex}{$#3$}}} \raisebox{-.6ex}{$\begin{array}[b]{cc} \cline{1-1}\cline{2-2}% \lr{|}{|}{1}\&\lr{|}{|}{2}\\ % \cline{1-1}\cline{2-2}% \lr{|}{|}{3}\&\lr{|}{|}{4}\\ % \cline{1-1}\cline{2-2}% \end{array}$} }
Class: Tableaux_all
self) |
TESTS:
sage: T = Tableaux() sage: T == loads(dumps(T)) True
Functions: iterator,
list
self) |
TESTS:
sage: Tableaux().iterator() Traceback (most recent call last): ... NotImplementedError
self) |
TESTS:
sage: Tableaux().list() Traceback (most recent call last): ... NotImplementedError
Special Functions: __contains__,
__init__,
__repr__
self, x) |
TESTS:
sage: T = Tableaux() sage: [[1,2],[3,4]] in T True sage: [[1,2],[3]] in T True sage: [1,2,3] in T False
self) |
TESTS:
sage: repr(Tableaux()) 'Tableaux'
Class: Tableaux_n
self, n) |
TESTS:
sage: T = Tableaux(3) sage: T == loads(dumps(T)) True
Functions: iterator,
list
self) |
TESTS:
sage: Tableaux(3).iterator() Traceback (most recent call last): ... NotImplementedError
self) |
TESTS:
sage: Tableaux(3).list() Traceback (most recent call last): ... NotImplementedError
Special Functions: __contains__,
__init__,
__repr__
self, x) |
sage: [[2,4],[1,3]] in Tableaux(3) False sage: [[2,4], [1]] in Tableaux(3) True
self) |
TESTS:
sage: repr(Tableaux(4)) 'Tableaux of size 4'