18.35 Tableaux

Module: sage.combinat.tableau

Tableaux

Module-level Functions

SemistandardTableaux( [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]]]

StandardTableaux( [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]]]

Tableau( 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

Tableaux( [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

from_chain( 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]]

from_shape_and_word( 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

class SemistandardTableaux_all
SemistandardTableaux_all( self)

TESTS:

sage: SST = SemistandardTableaux()
sage: SST == loads(dumps(SST))
True

Functions: list

list( self)

TESTS:

sage: SemistandardTableaux().list()
Traceback (most recent call last):
...
NotImplementedError

Special Functions: __contains__,$ \,$ __init__

__contains__( 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

class SemistandardTableaux_n
SemistandardTableaux_n( self, n)

TESTS:

sage: SST = SemistandardTableaux(3)
sage: SST == loads(dumps(SST))
True

Functions: count,$ \,$ iterator

count( 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

iterator( 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__

__contains__( 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

__repr__( self)

TESTS:

sage: repr(SemistandardTableaux(3))
'Semistandard tableaux of size 3'

Class: SemistandardTableaux_nmu

class SemistandardTableaux_nmu
SemistandardTableaux_nmu( self, n, mu)

TESTS:

sage: SST = SemistandardTableaux(3, [2,1])
sage: SST == loads(dumps(SST))
True

Functions: count,$ \,$ iterator

count( self)

sage: SemistandardTableaux(3, [2,1]).count()
2
sage: SemistandardTableaux(4, [2,2]).count()
3

iterator( 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__

__contains__( 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

__repr__( self)

TESTS:

sage: repr(SemistandardTableaux(3, [2,1]))
'Semistandard tableaux of size 3 and evaluation [2, 1]'

Class: SemistandardTableaux_p

class SemistandardTableaux_p
SemistandardTableaux_p( self, p)

TESTS:

sage: SST = SemistandardTableaux([2,1])
sage: SST == loads(dumps(SST))
True

Functions: count,$ \,$ iterator

count( 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

iterator( 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__

__contains__( 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

__repr__( self)

TESTS:

sage: repr(SemistandardTableaux([2,1]))
'Semistandard tableaux of shape [2, 1]'

Class: SemistandardTableaux_pmu

class SemistandardTableaux_pmu
SemistandardTableaux_pmu( self, p, mu)

TESTS:

sage: SST = SemistandardTableaux([2,1], [2,1])
sage: SST == loads(dumps(SST))
True

Functions: count,$ \,$ list

count( 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

list( 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__

__contains__( 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

__repr__( self)

TESTS:

sage: repr(SemistandardTableaux([2,1],[2,1]))
'Semistandard tableaux of shape [2, 1] and evaluation [2, 1]'

Class: StandardTableaux_all

class StandardTableaux_all
StandardTableaux_all( self)

TESTS:

sage: ST = StandardTableaux()
sage: ST == loads(dumps(ST))
True

Functions: list

list( self)

TESTS:

sage: StandardTableaux().list()
Traceback (most recent call last):
...
NotImplementedError

Special Functions: __contains__,$ \,$ __init__,$ \,$ __repr__

__contains__( 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

__repr__( self)

TESTS:

sage: repr(StandardTableaux())
'Standard tableaux'

Class: StandardTableaux_n

class StandardTableaux_n
StandardTableaux_n( self, n)

TESTS:

sage: ST = StandardTableaux(3)
sage: ST == loads(dumps(ST))
True

Functions: count,$ \,$ iterator

count( 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

iterator( 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__

__contains__( 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)
[]

__repr__( self)

TESTS:

sage: repr(StandardTableaux(3))
'Standard tableaux of size 3'

Class: StandardTableaux_partition

class StandardTableaux_partition
StandardTableaux_partition( self, p)

TESTS:

sage: ST = StandardTableaux([2,1,1])
sage: ST == loads(dumps(ST))
True

Functions: count,$ \,$ iterator,$ \,$ list,$ \,$ random_element

count( 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

iterator( 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]]]

list( 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]]]

random_element( 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__

__contains__( 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

__repr__( self)

TESTS:

sage: repr(StandardTableaux([2,1,1]))
'Standard tableaux of shape [2, 1, 1]'

Class: Tableau_class

class Tableau_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

anti_restrict( 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]]

atom( self)

sage: Tableau([[1,2],[3,4]]).atom()
[2, 2]
sage: Tableau([[1,2,3],[4,5],[6]]).atom()
[3, 2, 1]

attacking_pairs( 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))]

boxes( 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)]

bump( 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]]

bump_multiply( 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]]

charge( 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

cocharge( 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

column_stabilizer( 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

conjugate( self)

Returns the conjugate of the tableau t.

sage: Tableau([[1,2],[3,4]]).conjugate()
[[1, 3], [2, 4]]

corners( 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]]

descents( 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)]

down( 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]]]

down_list( 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]]]

entry( 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

evaluation( self)

Returns the evaluation of the word from tableau t.

sage: Tableau([[1,2],[3,4]]).evaluation()
[1, 1, 1, 1]

height( 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

insert_word( 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]]

inversion_number( 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

inversions( 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))]

is_rectangular( 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

is_standard( 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

k_weight( 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]

katabolism( 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]]

katabolism_projector( 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]]

katabolism_sequence( 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]]]

lambda_katabolism( 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]]

last_letter_lequal( 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]

major_index( 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

pp( self)

Returns a pretty print string of the tableau.

sage: Tableau([[1,2,3],[3,4],[5]]).pp()
  1  2  3
  3  4
  5

promotion( 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

promotion_inverse( 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]]

promotion_operator( 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]]]

raise_action_from_words( 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]]

reduced_lambda_katabolism( 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

restrict( 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]]

rotate_180( self)

Returns the tableau obtained by rotating t by 180 degrees.

sage: Tableau([[1,2],[3,4]]).rotate_180()
[[4, 3], [2, 1]]

row_stabilizer( 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

schensted_insert( 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]]

shape( self)

Returns the shape of a tableau t.

sage: Tableau([[1,2,3],[4,5],[6]]).shape()
[3, 2, 1]

size( 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

slide_multiply( 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]]

socle( self)

sage: Tableau([[1,2],[3,4]]).socle()
2
sage: Tableau([[1,2,3,4]]).socle()
4

symmetric_group_action_on_values( 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]]

to_chain( 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()
[[]]

to_list( 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]]

to_permutation( 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]

to_word( 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]

to_word_by_column( 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]

to_word_by_row( 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]

up( 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]]]

up_list( 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]]]

vertical_flip( 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]]

weight( 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

__div__( 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]]

_heights( 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]

_latex_( 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}$}
}

_left_schensted_insert( 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]]

_right_schensted_insert( 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]]

_tex_from_array( 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

class Tableaux_all
Tableaux_all( self)

TESTS:

sage: T = Tableaux()
sage: T == loads(dumps(T))
True

Functions: iterator,$ \,$ list

iterator( self)

TESTS:

sage: Tableaux().iterator()
Traceback (most recent call last):
...
NotImplementedError

list( self)

TESTS:

sage: Tableaux().list()
Traceback (most recent call last):
...
NotImplementedError

Special Functions: __contains__,$ \,$ __init__,$ \,$ __repr__

__contains__( 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

__repr__( self)

TESTS:

sage: repr(Tableaux())
'Tableaux'

Class: Tableaux_n

class Tableaux_n
Tableaux_n( self, n)

TESTS:

sage: T = Tableaux(3)
sage: T == loads(dumps(T))
True

Functions: iterator,$ \,$ list

iterator( self)

TESTS:

sage: Tableaux(3).iterator()
Traceback (most recent call last):
...
NotImplementedError

list( self)

TESTS:

sage: Tableaux(3).list()
Traceback (most recent call last):
...
NotImplementedError

Special Functions: __contains__,$ \,$ __init__,$ \,$ __repr__

__contains__( self, x)

sage: [[2,4],[1,3]] in Tableaux(3)
False
sage: [[2,4], [1]] in Tableaux(3)
True

__repr__( self)

TESTS:

sage: repr(Tableaux(4))
'Tableaux of size 4'

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