Tableaux

AUTHORS:

  • Mike Hansen (2007): initial version
  • Jason Bandlow (2011): updated to use Parent/Element model, and many minor fixes
  • Andrew Mathas (2012-13): completed the transition to the parent/element model begun by Jason Bandlow
  • Travis Scrimshaw (11-22-2012): Added tuple options, changed *katabolism* to *catabolism*. Cleaned up documentation.

This file consists of the following major classes:

Element classes:

Factory classes:

Parent classes:

For display options, see Tableaux.global_options().

class sage.combinat.tableau.SemistandardTableau(parent, t)

Bases: sage.combinat.tableau.Tableau

A class to model a semistandard tableau.

INPUT:

  • t – a tableau, a list of lists, or an empty list

OUTPUT:

  • A SemistandardTableau object constructed from t.

A semistandard tableau is a tableau whose entries are positive integers, which are weakly increasing in rows and strictly increasing down columns.

EXAMPLES:

sage: t = SemistandardTableau([[1,2,3],[2,3]]); t
[[1, 2, 3], [2, 3]]
sage: t.shape()
[3, 2]
sage: t.pp() # pretty print
1 2 3
2 3
sage: t = Tableau([[1,2],[2]])
sage: s = SemistandardTableau(t); s
[[1, 2], [2]]
sage: SemistandardTableau([]) # The empty tableau
[]

When using code that will generate a lot of tableaux, it is slightly more efficient to construct a SemistandardTableau from the appropriate Parent object:

sage: SST = SemistandardTableaux()
sage: SST([[1, 2, 3], [4, 5]])
[[1, 2, 3], [4, 5]]

TESTS:

sage: SemistandardTableau([[1,2,3],[1]])
Traceback (most recent call last):
...
ValueError: [[1, 2, 3], [1]] is not a column strict tableau

sage: SemistandardTableau([[1,2,1]])
Traceback (most recent call last):
...
ValueError: The rows of [[1, 2, 1]] are not weakly increasing

sage: SemistandardTableau([[0,1]])
Traceback (most recent call last):
...
ValueError: entries must be positive integers
class sage.combinat.tableau.SemistandardTableaux(**kwds)

Bases: sage.combinat.tableau.Tableaux

A factory class for the various classes of semistandard tableaux.

INPUT:

Keyword arguments:

  • size – The size of the tableaux
  • shape – The shape of the tableaux
  • eval – The weight (also called content or evaluation) of the tableaux
  • max_entry – A maximum entry for the tableaux. This can be a positive integer or infinity (oo). If size or shape are specified, max_entry defaults to be size or the size of shape.

Positional arguments:

  • The first argument is interpreted as either size or shape according to whether it is an integer or a partition
  • The second keyword argument will always be interpreted as eval

OUTPUT:

  • The appropriate class, after checking basic consistency tests. (For example, specifying eval implies a value for \(max_entry\)).

A semistandard tableau is a tableau whose entries are positive integers, which are weakly increasing in rows and strictly increasing down columns. Note that Sage uses the English convention for partitions and tableaux; the longer rows are displayed on top.

Classes of semistandard tableaux can be iterated over if and only if there is some restriction.

EXAMPLES:

sage: SST = SemistandardTableaux([2,1]); SST
Semistandard tableaux of shape [2, 1] and maximum entry 3
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 and maximum entry 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]]]

sage: SST = SemistandardTableaux(3, max_entry=2); SST
Semistandard tableaux of size 3 and maximum entry 2
sage: SST.list()
[[[1, 1, 1]],
 [[1, 1, 2]],
 [[1, 2, 2]],
 [[2, 2, 2]],
 [[1, 1], [2]],
 [[1, 2], [2]]]

sage: SST = SemistandardTableaux(3, max_entry=oo); SST
Semistandard tableaux of size 3
sage: SST[123]
[[3, 4], [6]]

sage: SemistandardTableaux(max_entry=2)[11]
[[1, 1], [2]]

sage: SemistandardTableaux()[0]
[]
Element

alias of SemistandardTableau

class sage.combinat.tableau.SemistandardTableaux_all(max_entry=None)

Bases: sage.combinat.tableau.SemistandardTableaux, sage.sets.disjoint_union_enumerated_sets.DisjointUnionEnumeratedSets

All semistandard tableaux.

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

list()

TESTS:

sage: SemistandardTableaux().list()
Traceback (most recent call last):
...
NotImplementedError
class sage.combinat.tableau.SemistandardTableaux_shape(p, max_entry=None)

Bases: sage.combinat.tableau.SemistandardTableaux

Semistandard tableaux of fixed shape \(p\) with a given max entry.

A semistandard tableau with max entry \(i\) is required to have all its entries less or equal to \(i\). It is not required to actually contain an entry \(i\).

INPUT:

  • p – A partition
  • max_entry – The max entry; defaults to the size of p.

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

cardinality()

Returns the cardinality of self.

EXAMPLES:

sage: SemistandardTableaux([2,1]).cardinality()
8
sage: SemistandardTableaux([2,2,1]).cardinality()
75
sage: SymmetricFunctions(QQ).schur()([2,2,1]).expand(5)(1,1,1,1,1) # cross check
75
sage: SemistandardTableaux([5]).cardinality()
126
sage: SemistandardTableaux([3,2,1]).cardinality()
896

sage: SemistandardTableaux([3,2,1], max_entry=7).cardinality()
2352
class sage.combinat.tableau.SemistandardTableaux_shape_inf(p)

Bases: sage.combinat.tableau.SemistandardTableaux

Semistandard tableaux of fixed shape \(p\) and no maximum entry.

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

class sage.combinat.tableau.SemistandardTableaux_shape_weight(p, mu)

Bases: sage.combinat.tableau.SemistandardTableaux_shape

Semistandard tableaux of fixed shape \(p\) and weight \(\mu\).

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

cardinality()

Returns the number of semistandard tableaux of the given shape and weight, as computed by kostka_number function of symmetrica.

EXAMPLES:

sage: SemistandardTableaux([2,2], [2, 1, 1]).cardinality()
1
sage: SemistandardTableaux([2,2,2], [2, 2, 1,1]).cardinality()
1
sage: SemistandardTableaux([2,2,2], [2, 2, 2]).cardinality()
1
sage: SemistandardTableaux([3,2,1], [2, 2, 2]).cardinality()
2
list()

Return a list of all semistandard tableaux in self generated by symmetrica.

EXAMPLES:

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]]]
class sage.combinat.tableau.SemistandardTableaux_size(n, max_entry=None)

Bases: sage.combinat.tableau.SemistandardTableaux

Semistandard tableaux of fixed size \(n\).

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

cardinality()

Return the cardinality of self.

EXAMPLES:

sage: SemistandardTableaux(3).cardinality()
19
sage: SemistandardTableaux(4).cardinality()
116
sage: SemistandardTableaux(4, max_entry=2).cardinality()
9
sage: SemistandardTableaux(4, max_entry=10).cardinality()
4225
sage: ns = range(1, 6)
sage: ssts = [ SemistandardTableaux(n) for n in ns ]
sage: all([sst.cardinality() == len(sst.list()) for sst in ssts])
True
class sage.combinat.tableau.SemistandardTableaux_size_inf(n)

Bases: sage.combinat.tableau.SemistandardTableaux

Semistandard tableaux of fixed size \(n\) with no maximum entry.

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

list()

TESTS:

sage: SemistandardTableaux(3, max_entry=oo).list()
Traceback (most recent call last):
...
NotImplementedError
class sage.combinat.tableau.SemistandardTableaux_size_weight(n, mu)

Bases: sage.combinat.tableau.SemistandardTableaux

Semistandard tableaux of fixed size \(n\) and weight \(\mu\).

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

cardinality()

Return the cardinality of self.

EXAMPLES:

sage: SemistandardTableaux(3, [2,1]).cardinality()
2
sage: SemistandardTableaux(4, [2,2]).cardinality()
3
class sage.combinat.tableau.StandardTableau(parent, t)

Bases: sage.combinat.tableau.SemistandardTableau

A class to model a standard tableau.

INPUT:

  • t – a Tableau, a list of lists, or an empty list

OUTPUT:

  • A StandardTableau object constructed from t.

A standard tableau is a semistandard tableau whose entries are exactly the positive integers from 1 to \(n\), where \(n\) is the size of the tableau.

EXAMPLES:

sage: t = StandardTableau([[1,2,3],[4,5]]); t
[[1, 2, 3], [4, 5]]
sage: t.shape()
[3, 2]
sage: t.pp() # pretty print
1 2 3
4 5
sage: t.is_standard()
True
sage: StandardTableau([]) # The empty tableau
[]

When using code that will generate a lot of tableaux, it is slightly more efficient to construct a StandardTableau from the appropriate Parent object:

sage: ST = StandardTableaux()
sage: ST([[1, 2, 3], [4, 5]])
[[1, 2, 3], [4, 5]]
content(k, multicharge=[0])

Returns the content of k in a standard tableau. That is, if k appears in row \(r\) and column \(c\) of the tableau then we return \(c-r\).

The multicharge is a list of length 1 which gives an offset for all of the contents. It is included mainly for compatibility with TableauTuple.

EXAMPLES:

sage: StandardTableau([[1,2],[3,4]]).content(3)
-1

sage: StandardTableau([[1,2],[3,4]]).content(6)
Traceback (most recent call last):
...
ValueError: 6 does not appear in tableau
dominates(t)

Return True if self dominates the tableau t. That is, if the shape of the tableau restricted to \(k\) dominates the shape of t restricted to \(k\), for \(k = 1, 2, \ldots, n\).

When the two tableaux have the same shape, then this ordering coincides with the Bruhat ordering for the corresponding permutations.

INPUT:

  • t – A tableau

EXAMPLES:

sage: s=StandardTableau([[1,2,3],[4,5]])
sage: t=StandardTableau([[1,2],[3,5],[4]])
sage: s.dominates(t)
True
sage: t.dominates(s)
False
sage: all(StandardTableau(s).dominates(t) for t in StandardTableaux([3,2]))
True
sage: s.dominates([[1,2,3,4,5]])
False
down()

An iterator for all the standard tableaux that can be obtained from self by removing a cell. Note that this iterates just over a single tableau (or nothing if self is empty).

EXAMPLES:

sage: t = StandardTableau([[1,2],[3]])
sage: [x for x in t.down()]
[[[1, 2]]]
sage: t = StandardTableau([])
sage: [x for x in t.down()]
[]
down_list()

Return a list of all the standard tableaux that can be obtained from self by removing a cell. Note that this is just a singleton list if self is nonempty, and an empty list otherwise.

EXAMPLES:

sage: t = StandardTableau([[1,2],[3]])
sage: t.down_list()
[[[1, 2]]]
sage: t = StandardTableau([])
sage: t.down_list()
[]
is_standard()

Return True since self is a standard tableau.

EXAMPLES:

sage: StandardTableau([[1, 3], [2, 4]]).is_standard()
True
promotion(m=None)

Return the image of self under the promotion operator.

The promotion operator, applied to a standard tableau \(t\), does the following:

Remove the letter \(n\) from \(t\), thus leaving a hole where it used to be. Apply jeu de taquin to move this hole southwest (in French notation) until it reaches the inner boundary of \(t\). Fill \(0\) into the hole once jeu de taquin has completed. Finally, add \(1\) to each letter in the tableau. The resulting standard tableau is the image of \(t\) under the promotion operator.

This definition of promotion is precisely the one given in [Hai1992] (p. 90). It is the inverse of the maps called “promotion” in [Sg2011] (p. 23) and in [St2009].

See the promotion() method for a more general operator.

EXAMPLES:

sage: ST = StandardTableaux(7)
sage: all( st.promotion().promotion_inverse() == st for st in ST ) # long time
True
sage: all( st.promotion_inverse().promotion() == st for st in ST ) # long time
True
sage: st = StandardTableau([[1,2,5],[3,4]])
sage: parent(st.promotion())
Standard tableaux
promotion_inverse(m=None)

Return the image of self under the inverse promotion operator. The optional variable \(m\) should be set to the size of self minus \(1\) for a minimal speedup; otherwise, it defaults to this number.

The inverse promotion operator, applied to a standard tableau \(t\), does the following:

Remove the letter \(1\) from \(t\), thus leaving a hole where it used to be. Apply jeu de taquin to move this hole northeast (in French notation) until it reaches the outer boundary of \(t\). Fill \(n + 1\) into this hole, where \(n\) is the size of \(t\). Finally, subtract \(1\) from each letter in the tableau. This yields a new standard tableau.

This definition of inverse promotion is the map called “promotion” in [Sg2011] (p. 23) and in [St2009], and is the inverse of the map called “promotion” in [Hai1992] (p. 90).

See the promotion_inverse() method for a more general operator.

EXAMPLES:

sage: t = StandardTableau([[1,3],[2,4]])
sage: t.promotion_inverse()
[[1, 2], [3, 4]]

We check the equivalence of two definitions of inverse promotion on standard tableaux:

sage: ST = StandardTableaux(7)
sage: def bk_promotion_inverse7(st):
....:     st2 = st
....:     for i in range(1, 7):
....:         st2 = st2.bender_knuth_involution(i, check=False)
....:     return st2
sage: all( bk_promotion_inverse7(st) == st.promotion_inverse() for st in ST ) # long time
True
standard_descents()

Return a list of the integers \(i\) such that \(i\) appears strictly further north than \(i + 1\) in self (this is not to say that \(i\) and \(i + 1\) must be in the same column). The list is sorted in increasing order.

EXAMPLES:

sage: StandardTableau( [[1,3,4],[2,5]] ).standard_descents()
[1, 4]
sage: StandardTableau( [[1,2],[3,4]] ).standard_descents()
[2]
sage: StandardTableau( [[1,2,5],[3,4],[6,7],[8],[9]] ).standard_descents()
[2, 5, 7, 8]
sage: StandardTableau( [] ).standard_descents()
[]
standard_major_index()

Return the major index of the standard tableau self in the standard meaning of the word. The major index is defined to be the sum of the descents of self (see standard_descents() for their definition).

EXAMPLES:

sage: StandardTableau( [[1,4,5],[2,6],[3]] ).standard_major_index()
8
sage: StandardTableau( [[1,2],[3,4]] ).standard_major_index()
2
sage: StandardTableau( [[1,2,3],[4,5]] ).standard_major_index()
3
standard_number_of_descents()

Return the number of all integers \(i\) such that \(i\) appears strictly further north than \(i + 1\) in self (this is not to say that \(i\) and \(i + 1\) must be in the same column). A list of these integers can be obtained using the standard_descents() method.

EXAMPLES:

sage: StandardTableau( [[1,2],[3,4],[5]] ).standard_number_of_descents()
2
sage: StandardTableau( [] ).standard_number_of_descents()
0
sage: tabs = StandardTableaux(5)
sage: all( t.standard_number_of_descents() == t.schuetzenberger_involution().standard_number_of_descents() for t in tabs )
True
up()

An iterator for all the standard tableaux that can be obtained from self by adding a cell.

EXAMPLES:

sage: t = StandardTableau([[1,2]])
sage: [x for x in t.up()]
[[[1, 2, 3]], [[1, 2], [3]]]
up_list()

Return a list of all the standard tableaux that can be obtained from self by adding a cell.

EXAMPLES:

sage: t = StandardTableau([[1,2]])
sage: t.up_list()
[[[1, 2, 3]], [[1, 2], [3]]]
class sage.combinat.tableau.StandardTableaux(**kwds)

Bases: sage.combinat.tableau.SemistandardTableaux

A factory for the various classes of standard tableaux.

INPUT:

  • Either a non-negative integer (possibly specified with the keyword n) or a partition.

OUTPUT:

  • With no argument, the class of all standard tableaux
  • With a non-negative integer argument, n, the class of all standard tableaux of size n
  • With a partition argument, the class of all standard tableaux of that shape.

A standard tableau is a semistandard tableaux which contains each of the entries from 1 to n exactly once.

All classes of standard tableaux are iterable.

EXAMPLES:

sage: ST = StandardTableaux(3); ST
Standard tableaux of size 3
sage: ST.first()
[[1, 2, 3]]
sage: ST.last()
[[1], [2], [3]]
sage: ST.cardinality()
4
sage: ST.list()
[[[1, 2, 3]], [[1, 3], [2]], [[1, 2], [3]], [[1], [2], [3]]]

TESTS:

sage: StandardTableaux()([])
[]
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.cardinality()
2
sage: ST.list()
[[[1, 3], [2, 4]], [[1, 2], [3, 4]]]
Element

alias of StandardTableau

class sage.combinat.tableau.StandardTableaux_all

Bases: sage.combinat.tableau.StandardTableaux, sage.sets.disjoint_union_enumerated_sets.DisjointUnionEnumeratedSets

All standard tableaux.

class sage.combinat.tableau.StandardTableaux_shape(p)

Bases: sage.combinat.tableau.StandardTableaux

Semistandard tableaux of a fixed shape \(p\).

Warning

Input is not checked; please use SemistandardTableaux to ensure the options are properly parsed.

cardinality()

Return the number of standard Young tableaux of this shape.

This method uses the so-called hook length formula, a formula for the number of Young tableaux associated with a given partition. The formula says the following: Let \(\lambda\) be a partition. For each cell \(c\) of the Young diagram of \(\lambda\), let the hook length of \(c\) be defined as \(1\) plus the number of cells horizontally to the right of \(c\) plus the number of cells vertically below \(c\). The number of standard Young tableaux of shape \(\lambda\) is then \(n!\) divided by the product of the hook lengths of the shape of \(\lambda\), where \(n = |\lambda|\).

For example, consider the partition [3,2,1] of 6 with Ferrers diagram:

# # #
# #
#

When we fill in the cells with their respective hook lengths, we obtain:

5 3 1
3 1
1

The hook length formula returns

\[\frac{6!}{5 \cdot 3 \cdot 1 \cdot 3 \cdot 1 \cdot 1} = 16.\]

EXAMPLES:

sage: StandardTableaux([3,2,1]).cardinality()
16
sage: StandardTableaux([2,2]).cardinality()
2
sage: StandardTableaux([5]).cardinality()
1
sage: StandardTableaux([6,5,5,3]).cardinality()
6651216
sage: StandardTableaux([]).cardinality()
1

REFERENCES:

list()

Return a list of the standard Young tableaux of the specified shape.

EXAMPLES:

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

Return a random standard tableau of the given shape using the Greene-Nijenhuis-Wilf Algorithm.

EXAMPLES:

sage: StandardTableaux([2,2]).random_element()
[[1, 2], [3, 4]]
sage: StandardTableaux([]).random_element()
[]
class sage.combinat.tableau.StandardTableaux_size(n)

Bases: sage.combinat.tableau.StandardTableaux

Standard tableaux of fixed size \(n\).

Warning

Input is not checked; please use StandardTableaux to ensure the options are properly parsed.

cardinality()

Return the number of all standard tableaux of size n.

The number of standard tableaux of size \(n\) is equal to the number of involutions in the symmetric group \(S_n\). This is a consequence of the symmetry of the RSK correspondence, that if \(\sigma \mapsto (P, Q)\), then \(\sigma^{-1} \mapsto (Q, P)\). For more information, see Wikipedia article Robinson-Schensted-Knuth_correspondence#Symmetry.

ALGORITHM:

The algorithm uses the fact that standard tableaux of size n are in bijection with the involutions of size n, (see page 41 in section 4.1 of [Ful1997]). For each number of fixed points, you count the number of ways to choose those fixed points multiplied by the number of perfect matchings on the remaining values.

REFERENCES:

[Ful1997](1, 2, 3) William Fulton, Young Tableaux. Cambridge University Press, 1997.

EXAMPLES:

sage: StandardTableaux(3).cardinality()
4
sage: ns = [1,2,3,4,5,6]
sage: sts = [StandardTableaux(n) for n in ns]
sage: all([st.cardinality() == len(st.list()) for st in sts])
True
sage: StandardTableaux(50).cardinality()
27886995605342342839104615869259776

TESTS:

sage: def cardinality_using_hook_formula(n):
....:     c = 0
....:     for p in Partitions(n):
....:         c += StandardTableaux(p).cardinality()
....:     return c
sage: all([cardinality_using_hook_formula(i) == StandardTableaux(i).cardinality() for i in range(10)])
True
class sage.combinat.tableau.Tableau(parent, t)

Bases: sage.combinat.combinat.CombinatorialObject, sage.structure.element.Element

A class to model a tableau.

INPUT:

  • t – a Tableau, a list of lists, or an empty list

OUTPUT:

  • A Tableau object constructed from t.

A tableau in Sage is a finite list of lists, whose lengths are weakly decreasing, or an empty list, representing the empty tableau. The entries of a tableau can be any sage object.

Note that Sage uses the English convention for partitions and tableaux; the longer rows are displayed on top.

EXAMPLES:

sage: t = Tableau([[1,2,3],[4,5]]); t
[[1, 2, 3], [4, 5]]
sage: t.shape()
[3, 2]
sage: t.pp() # pretty print
1 2 3
4 5
sage: t.is_standard()
True

sage: Tableau([['a','c','b'],[[],(2,1)]])
[['a', 'c', 'b'], [[], (2, 1)]]
sage: Tableau([]) # The empty tableau
[]

When using code that will generate a lot of tableaux, it is slightly more efficient to construct a Tableau from the appropriate Parent object:

sage: T = Tableaux()
sage: T([[1, 2, 3], [4, 5]])
[[1, 2, 3], [4, 5]]

TESTS:

sage: Tableau([[1],[2,3]])
Traceback (most recent call last):
...
ValueError: A tableau must be a list of lists of weakly decreasing length.
sage: Tableau([1,2,3])
Traceback (most recent call last):
...
ValueError: A tableau must be a list of lists.
add_entry(cell, m)

Set the entry in cell equal to m. If the cell does not exist then extend the tableau, otherwise just replace the entry.

EXAMPLES:

sage: s=StandardTableau([[1,2,5],[3,4]]); s.pp()
  1  2  5
  3  4
sage: t=s.add_entry( (1,2), 6); t.pp()
  1  2  5
  3  4  6
sage: t.category()
Category of elements of Standard tableaux
sage: s.add_entry( (2,0), 6).pp()
  1  2  5
  3  4
  6
sage: u=s.add_entry( (1,2), 3); u.pp()
  1  2  5
  3  4  3
sage: u.category()
Category of elements of Tableaux
sage: s.add_entry( (2,2),3)
Traceback (most recent call last):
...
IndexError: (2, 2) is not an addable cell of the tableau
anti_restrict(n)

Return the skew tableau formed by removing all of the cells from self that are filled with a number at most \(n\).

EXAMPLES:

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]]
sage: t.anti_restrict(5)
[[None, None, None], [None, None]]
atom()

EXAMPLES:

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

Deprecated in trac ticket #15327. Use T.shape().attacking_pairs() instead for a tableau T.

Return a list of the attacking pairs of self. A pair of cells \((c, d)\) of a Young tableau is said to be attacking if one of the following conditions holds:

  1. \(c\) and \(d\) lie in the same row with \(c\) strictly to the west of \(d\).
  2. \(c\) is in the row immediately to the south of \(d\), and \(c\) lies strictly east of \(d\).

This only depends on the shape of self, not on the entries.

EXAMPLES:

sage: t = Tableau([[1,2,3],[2,5]])
sage: t.attacking_pairs()
doctest:...: DeprecationWarning: attacking_pairs() is deprecated. Instead, use shape().attacking_pairs()
See http://trac.sagemath.org/15327 for details.
[((0, 0), (0, 1)),
 ((0, 0), (0, 2)),
 ((0, 1), (0, 2)),
 ((1, 0), (1, 1)),
 ((1, 1), (0, 0))]
bender_knuth_involution(k, rows=None, check=True)

Return the image of self under the \(k\)-th Bender–Knuth involution, assuming self is a semistandard tableau.

Let \(T\) be a tableau, then a lower free `k` in `T` means a cell of \(T\) which is filled with the integer \(k\) and whose direct lower neighbor is not filled with the integer \(k + 1\) (in particular, this lower neighbor might not exist at all). Let an upper free `k + 1` in `T` mean a cell of \(T\) which is filled with the integer \(k + 1\) and whose direct upper neighbor is not filled with the integer \(k\) (in particular, this neighbor might not exist at all). It is clear that for any row \(r\) of \(T\), the lower free \(k\)‘s and the upper free \(k + 1\)‘s in \(r\) together form a contiguous interval or \(r\).

The `k`-th Bender–Knuth switch at row `i` changes the entries of the cells in this interval in such a way that if it used to have \(a\) entries of \(k\) and \(b\) entries of \(k + 1\), it will now have \(b\) entries of \(k\) and \(a\) entries of \(k + 1\). For fixed \(k\), the \(k\)-th Bender–Knuth switches for different \(i\) commute. The composition of the \(k\)-th Bender–Knuth switches for all rows is called the `k`-th Bender-Knuth involution. This is used to show that the Schur functions defined by semistandard tableaux are symmetric functions.

INPUT:

  • k – an integer
  • rows – (Default None) When set to None, the method computes the \(k\)-th Bender–Knuth involution as defined above. When an iterable, this computes the composition of the \(k\)-th Bender–Knuth switches at row \(i\) over all \(i\) in rows. When set to an integer \(i\), the method computes the \(k\)-th Bender–Knuth switch at row \(i\). Note the indexing of the rows starts with \(1\).
  • check – (Default: True) Check to make sure self is semistandard. Set to False to avoid this check.

OUTPUT:

The image of self under either the \(k\)-th Bender–Knuth involution, the \(k\)-th Bender–Knuth switch at a certain row, or the composition of such switches, as detailed in the INPUT section.

EXAMPLES:

sage: t = Tableau([[1,1,3,4,4,5,6,7],[2,2,4,6,7,7,7],[3,4,5,8,8,9],[6,6,7,10],[7,8,8,11],[8]])
sage: t.bender_knuth_involution(1) == t
True
sage: t.bender_knuth_involution(2)
[[1, 1, 2, 4, 4, 5, 6, 7], [2, 3, 4, 6, 7, 7, 7], [3, 4, 5, 8, 8, 9], [6, 6, 7, 10], [7, 8, 8, 11], [8]]
sage: t.bender_knuth_involution(3)
[[1, 1, 3, 3, 3, 5, 6, 7], [2, 2, 4, 6, 7, 7, 7], [3, 4, 5, 8, 8, 9], [6, 6, 7, 10], [7, 8, 8, 11], [8]]
sage: t.bender_knuth_involution(4)
[[1, 1, 3, 4, 5, 5, 6, 7], [2, 2, 4, 6, 7, 7, 7], [3, 5, 5, 8, 8, 9], [6, 6, 7, 10], [7, 8, 8, 11], [8]]
sage: t.bender_knuth_involution(5)
[[1, 1, 3, 4, 4, 5, 6, 7], [2, 2, 4, 5, 7, 7, 7], [3, 4, 6, 8, 8, 9], [5, 5, 7, 10], [7, 8, 8, 11], [8]]
sage: t.bender_knuth_involution(666) == t
True
sage: t.bender_knuth_involution(4, 2) == t
True
sage: t.bender_knuth_involution(4, 3)
[[1, 1, 3, 4, 4, 5, 6, 7], [2, 2, 4, 6, 7, 7, 7], [3, 5, 5, 8, 8, 9], [6, 6, 7, 10], [7, 8, 8, 11], [8]]

The rows keyword can be an iterator:

sage: t.bender_knuth_involution(6, iter([1,2])) == t
False
sage: t.bender_knuth_involution(6, iter([3,4])) == t
True

The Bender–Knuth involution is an involution:

sage: T = SemistandardTableaux(shape=[3,1,1], max_entry=4)
sage: all(all(t.bender_knuth_involution(k).bender_knuth_involution(k) == t for k in range(1,5)) for t in T)
True

The same holds for the single switches:

sage: all(all(t.bender_knuth_involution(k, j).bender_knuth_involution(k, j) == t for k in range(1,5) for j in range(1, 5)) for t in T)
True

Locality of the Bender–Knuth involutions:

sage: all(all(t.bender_knuth_involution(k).bender_knuth_involution(l) == t.bender_knuth_involution(l).bender_knuth_involution(k) for k in range(1,5) for l in range(1,5) if abs(k - l) > 1) for t in T)
True

Coxeter relation of the Bender–Knuth involutions (they have the form \((ab)^6 = 1\)):

sage: p = lambda t, k: t.bender_knuth_involution(k).bender_knuth_involution(k + 1)
sage: all(all(p(p(p(p(p(p(t,k),k),k),k),k),k) == t for k in range(1,5)) for t in T)
True

TESTS:

sage: t = Tableau([])
sage: t.bender_knuth_involution(3)
[]
bump(x)

Insert x into self using Schensted’s row-bumping (or row-insertion) algorithm.

EXAMPLES:

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 tableau is the unit in this monoid. See pp. 11-12 of [Ful1997].

EXAMPLES:

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

Remove the top row of self and insert it back in using column Schensted insertion (starting with the largest letter).

EXAMPLES:

sage: Tableau([]).catabolism()
[]
sage: Tableau([[1,2,3,4,5]]).catabolism()
[[1, 2, 3, 4, 5]]
sage: Tableau([[1,1,3,3],[2,3],[3]]).catabolism()
[[1, 1, 2, 3, 3, 3], [3]]
sage: Tableau([[1, 1, 2, 3, 3, 3], [3]]).catabolism()
[[1, 1, 2, 3, 3, 3, 3]]
catabolism_projector(parts)

EXAMPLES:

sage: t = Tableau([[1,1,3,3],[2,3],[3]])
sage: t.catabolism_projector([[4,2,1]])
[[1, 1, 3, 3], [2, 3], [3]]
sage: t.catabolism_projector([[1]])
[]
sage: t.catabolism_projector([[2,1],[1]])
[]
sage: t.catabolism_projector([[1,1],[4,1]])
[[1, 1, 3, 3], [2, 3], [3]]
catabolism_sequence()

Perform catabolism() on self until it returns a tableau consisting of a single row.

EXAMPLES:

sage: t = Tableau([[1,2,3,4,5,6,8],[7,9]])
sage: t.catabolism_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]]]
sage: Tableau([]).catabolism_sequence()
[[]]
cells()

Return a list of the coordinates of the cells of self.

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).cells()
[(0, 0), (0, 1), (1, 0), (1, 1)]
cells_containing(i)

Return the list of cells in which the letter \(i\) appears in the tableau self. The list is ordered with cells appearing from left to right.

Cells are given as pairs of coordinates \((a, b)\), where both rows and columns are counted from \(0\) (so \(a = 0\) means the cell lies in the leftmost column of the tableau, etc.).

EXAMPLES:

sage: t = Tableau([[1,1,3],[2,3,5],[4,5]])
sage: t.cells_containing(5)
[(2, 1), (1, 2)]
sage: t.cells_containing(4)
[(2, 0)]
sage: t.cells_containing(6)
[]

sage: t = Tableau([[1,1,2,4],[2,4,4],[4]])
sage: t.cells_containing(4)
[(2, 0), (1, 1), (1, 2), (0, 3)]

sage: t = Tableau([[1,1,2,8,9],[2,5,6,11],[3,7,7,13],[4,8,9],[5],[13],[14]])
sage: t.cells_containing(8)
[(3, 1), (0, 3)]

sage: Tableau([]).cells_containing(3)
[]
charge()

Return the charge of the reading word of self. See charge() for more information.

EXAMPLES:

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

Return the cocharge of the reading word of self. See cocharge() for more information.

EXAMPLES:

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()
3
sage: Tableau([[1,1,2],[2,3]]).cocharge()
2
sage: Tableau([[1,1,2,3],[2]]).cocharge()
2
sage: Tableau([[1,1,2,2],[3]]).cocharge()
1
sage: Tableau([[1,1,2,2,3]]).cocharge()
0
column_stabilizer()

Return the PermutationGroup corresponding to the column stabilizer of self.

This assumes that every integer from \(1\) to the size of self appears exactly once in self.

EXAMPLES:

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
components()

This function returns a list containing itself. It exists mainly for compatibility with TableauTuple as it allows constructions like the example below.

EXAMPLES:

sage: t = Tableau([[1,2,3],[4,5]]);
sage: for s in t.components(): print s.to_list()
[[1, 2, 3], [4, 5]]
conjugate(*args, **kwds)

Return the conjugate of self.

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).conjugate()
[[1, 3], [2, 4]]
sage: c = StandardTableau([[1,2],[3,4]]).conjugate()
sage: c.parent()
Standard tableaux
corners()

Return the corners of the tableau self.

EXAMPLES:

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

Return a list of the cells (i,j) such that self[i][j] > self[i-1][j].

Warning

This is not to be confused with the descents of a standard tableau.

EXAMPLES:

sage: Tableau( [[1,4],[2,3]] ).descents()
[(1, 0)]
sage: Tableau( [[1,2],[3,4]] ).descents()
[(1, 0), (1, 1)]
sage: Tableau( [[1,2,3],[4,5]] ).descents()
[(1, 0), (1, 1)]
down()

Deprecated in trac ticket #7983 since this is an operation on standard tableaux.

EXAMPLES:

sage: t = Tableau([[1,2],[3]])
sage: [x for x in t.down()]
doctest:...: DeprecationWarning: Tableau.down() is deprecated since it is an operation on standard tableaux.
See http://trac.sagemath.org/7983 for details.
[[[1, 2]]]
down_list()

Deprecated in trac ticket #7983 since this is an operation on standard tableaux.

EXAMPLES:

sage: t = Tableau([[1,2],[3]])
sage: t.down_list()
doctest:...: DeprecationWarning: Tableau.down_list() is deprecated since it is an operation on standard tableaux.
See http://trac.sagemath.org/7983 for details.
[[[1, 2]]]
entries()

Return a list of all entries of self, in the order obtained by reading across the rows from top to bottom.

EXAMPLES:

sage: t = Tableau([[1,3], [2]])
sage: t.entries()
[1, 3, 2]
entry(cell)

Returns the entry of cell cell in the tableau self. Here, cell should be given as a tuple \((i,j)\) of zero-based coordinates (so the northwesternmost cell in English notation is \((0,0)\)).

EXAMPLES:

sage: t = Tableau([[1,2],[3,4]])
sage: t.entry( (0,0) )
1
sage: t.entry( (1,1) )
4
evaluation()

Return the weight of the tableau self. Trailing zeroes are omitted when returning the weight.

The weight of a tableau \(T\) is the sequence \((a_1, a_2, a_3, \ldots )\), where \(a_k\) is the number of entries of \(T\) equal to \(k\). This sequence contains only finitely many nonzero entries.

The weight of a tableau \(T\) is the same as the weight of the reading word of \(T\), for any reading order.

EXAMPLES:

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

sage: Tableau([]).weight()
[]

sage: Tableau([[1,3,3,7],[4,2],[2,3]]).weight()
[1, 2, 3, 1, 0, 0, 1]

TESTS:

We check that this agrees with going to the word:

sage: t = Tableau([[1,3,4,7],[6,2],[2,3]])
sage: def by_word(T):
....:     ed = T.to_word().evaluation_dict()
....:     m = max(ed.keys()) + 1
....:     return [ed.get(k,0) for k in range(1,m)]
sage: by_word(t) == t.weight()
True
sage: SST = SemistandardTableaux(shape=[3,1,1])
sage: all(by_word(t) == t.weight() for t in SST)
True
flush()

Return the number of flush segments in self, as in [S14].

Let \(1 \le i < k \le r+1\) and suppose \(\ell\) is the smallest integer greater than \(k\) such that there exists an \(\ell\)-segment in the \((i+1)\)-st row of \(T\). A \(k\)-segment in the \(i\)-th row of \(T\) is called flush if the leftmost box in the \(k\)-segment and the leftmost box of the \(\ell\)-segment are in the same column of \(T\). If, however, no such \(\ell\) exists, then this \(k\)-segment is said to be flush if the number of boxes in the \(k\)-segment is equal to \(\theta_i\), where \(\theta_i = \lambda_i - \lambda_{i+1}\) and the shape of \(T\) is \(\lambda = (\lambda_1 > \lambda_2 > \cdots > \lambda_r)\). Denote the number of flush \(k\)-segments in \(T\) by \(\mathrm{flush}(T)\).

EXAMPLES:

sage: t = Tableau([[1,1,2,3,5],[2,3,5,5],[3,4]])
sage: t.flush()
3

sage: B = crystals.Tableaux("A4",shape=[4,3,2,1])
sage: t = B[32].to_tableau()
sage: t.flush()
4
height()

Return the height of self.

EXAMPLES:

sage: Tableau([[1,2,3],[4,5]]).height()
2
sage: Tableau([[1,2,3]]).height()
1
sage: Tableau([]).height()
0
insert_word(w, left=False)

Insert the word w into the tableau self letter by letter using Schensted insertion. By default, the word w is being processed from left to right, and the insertion used is row insertion. If the optional keyword left is set to True, the word w is being processed from right to left, and column insertion is used instead.

EXAMPLES:

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]]
sage: t1 = Tableau([[1,3],[2]])
sage: t1.insert_word([4,5])
[[1, 3, 4, 5], [2]]
sage: t1.insert_word([4,5], left=True)
[[1, 3], [2, 5], [4]]
inversion_number()

Return the inversion number of self.

The inversion number is defined to be the number of inversions of self minus the sum of the arm lengths of the descents of self (see the inversions() and descents() methods for the relevant definitions).

Warning

This has none of the meanings in which the word “inversion” is used in the theory of standard tableaux.

EXAMPLES:

sage: t = Tableau([[1,2,3],[2,5]])
sage: t.inversion_number()
0
sage: t = Tableau([[1,2,4],[3,5]])
sage: t.inversion_number()
0
inversions()

Return a list of the inversions of self.

Let \(T\) be a tableau. An inversion is an attacking pair \((c,d)\) of the shape of \(T\) (see attacking_pairs() for a definition of this) such that the entry of \(c\) in \(T\) is greater than the entry of \(d\).

Warning

Do not mistake this for the inversions of a standard tableau.

EXAMPLES:

sage: t = Tableau([[1,2,3],[2,5]])
sage: t.inversions()
[((1, 1), (0, 0))]
sage: t = Tableau([[1,4,3],[5,2],[2,6],[3]])
sage: t.inversions()
[((0, 1), (0, 2)), ((1, 0), (1, 1)), ((1, 1), (0, 0)), ((2, 1), (1, 0))]
is_column_strict()

Return True if self is a column strict tableau and False otherwise.

A tableau is column strict if the entries in each column are in (strictly) increasing order.

EXAMPLES:

sage: Tableau([[1, 3], [2, 4]]).is_column_strict()
True
sage: Tableau([[1, 2], [2, 4]]).is_column_strict()
True
sage: Tableau([[2, 3], [2, 4]]).is_column_strict()
False
sage: Tableau([[5, 3], [2, 4]]).is_column_strict()
False
is_increasing()

Return True if self is an increasing tableau and False otherwise.

A tableau is increasing if it is both row strict and column strict.

EXAMPLES:

sage: Tableau([[1, 3], [2, 4]]).is_increasing()
True
sage: Tableau([[1, 2], [2, 4]]).is_increasing()
True
sage: Tableau([[2, 3], [2, 4]]).is_increasing()
False
sage: Tableau([[5, 3], [2, 4]]).is_increasing()
False
sage: Tableau([[1, 2, 3], [2, 3], [3]]).is_increasing()
True
is_k_tableau(k)

Checks whether self is a valid weak \(k\)-tableau.

EXAMPLES:

sage: t = Tableau([[1,2,3],[2,3],[3]])
sage: t.is_k_tableau(3)
True
sage: t = Tableau([[1,1,3],[2,2],[3]])
sage: t.is_k_tableau(3)
False
is_key_tableau()

Return True if self is a key tableau or False otherwise.

A tableau is a key tableau if the set of entries in the \(j\)-th column are a subset of the set of entries in the \((j-1)\)-st column.

REFERENCES:

[LS90](1, 2) A. Lascoux, M.-P. Schutzenberger. Keys and standard bases, invariant theory and tableaux. IMA Volumes in Math and its Applications (D. Stanton, ED.). Southend on Sea, UK, 19 (1990). 125-144.
[Willis10](1, 2) M. Willis. A direct way to find the right key of a semistandard Young tableau. Arxiv 1110.6184v1.

EXAMPLES:

sage: t = Tableau([[1,1,1],[2,3],[3]])
sage: t.is_key_tableau()
True

sage: t = Tableau([[1,1,2],[2,3],[3]])
sage: t.is_key_tableau()
False
is_rectangular()

Return True if the tableau self is rectangular and False otherwise.

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).is_rectangular()
True
sage: Tableau([[1,2,3],[4,5],[6]]).is_rectangular()
False
sage: Tableau([]).is_rectangular()
True
is_row_strict()

Return True if self is a row strict tableau and False otherwise.

A tableau is row strict if the entries in each row are in (strictly) increasing order.

EXAMPLES:

sage: Tableau([[1, 3], [2, 4]]).is_row_strict()
True
sage: Tableau([[1, 2], [2, 4]]).is_row_strict()
True
sage: Tableau([[2, 3], [2, 4]]).is_row_strict()
True
sage: Tableau([[5, 3], [2, 4]]).is_row_strict()
False
is_standard()

Return True if self is a standard tableau and False otherwise.

EXAMPLES:

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(k)

Return the k-weight of self.

EXAMPLES:

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(*args, **kwds)

Deprecated: Use catabolism() instead. See trac ticket #13605 for details.

katabolism_projector(*args, **kwds)

Deprecated: Use catabolism_projector() instead. See trac ticket #13605 for details.

katabolism_sequence(*args, **kwds)

Deprecated: Use catabolism_sequence() instead. See trac ticket #13605 for details.

lambda_catabolism(part)

Return the part-catabolism of self, where part is a partition (which can be just given as an array).

For a partition \(\lambda\) and a tableau \(T\), the \(\lambda\)-catabolism of \(T\) is defined by performing the following steps.

  1. Truncate the parts of \(\lambda\) so that \(\lambda\) is contained in the shape of \(T\). Let \(m\) be the length of this partition.
  2. Let \(T_a\) be the first \(m\) rows of \(T\), and \(T_b\) be the remaining rows.
  3. Let \(S_a\) be the skew tableau \(T_a / \lambda\).
  4. Concatenate the reading words of \(S_a\) and \(T_b\), and insert into a tableau.

EXAMPLES:

sage: Tableau([[1,1,3],[2,4,5]]).lambda_catabolism([2,1])
[[3, 5], [4]]
sage: t = Tableau([[1,1,3,3],[2,3],[3]])
sage: t.lambda_catabolism([])
[[1, 1, 3, 3], [2, 3], [3]]
sage: t.lambda_catabolism([1])
[[1, 2, 3, 3, 3], [3]]
sage: t.lambda_catabolism([1,1])
[[1, 3, 3, 3], [3]]
sage: t.lambda_catabolism([2,1])
[[3, 3, 3, 3]]
sage: t.lambda_catabolism([4,2,1])
[]
sage: t.lambda_catabolism([5,1])
[[3, 3]]
sage: t.lambda_catabolism([4,1])
[[3, 3]]
lambda_katabolism(*args, **kwds)

Deprecated: Use lambda_catabolism() instead. See trac ticket #13605 for details.

last_letter_lequal(tab2)

Return True if self is less than or equal to tab2 in the last letter ordering.

EXAMPLES:

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

Return the left key tableau of self.

The left key tableau of a tableau \(T\) is the key tableau whose entries are weakly lesser than the corresponding entries in \(T\), and whose column reading word is subject to certain conditions. See [LS90] for the full definition.

ALGORITHM:

The following algorithm follows [Willis10]. Note that if \(T\) is a key tableau then the output of the algorithm is \(T\).

To compute the left key tableau \(L\) of a tableau \(T\) we iterate over the columns of \(T\). Let \(T_j\) be the \(j\)-th column of \(T\) and iterate over the entires in \(T_j\) from bottom to top. Initialize the corresponding entry \(k\) in \(L\) as the largest entry in \(T_j\). Scan the columns to the left of \(T_j\) and with each column update \(k\) to be the lowest entry in that column which is weakly less than \(k\). Update \(T_j\) and all columns to the left by removing all scanned entries.

See also

EXAMPLES:

sage: t = Tableau([[1,2],[2,3]])
sage: t.left_key_tableau()
[[1, 1], [2, 2]]
sage: t = Tableau([[1,1,2,4],[2,3,3],[4],[5]])
sage: t.left_key_tableau()
[[1, 1, 1, 2], [2, 2, 2], [4], [5]]

TESTS:

We check that if we have a key tableau, we return the same tableau:

sage: t = Tableau([[1,1,1,2], [2,2,2], [4], [5]])
sage: t.is_key_tableau()
True
sage: t.left_key_tableau() == t
True
level()

Returns the level of self, which is always 1.

This function exists mainly for compatibility with TableauTuple.

EXAMPLE:

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

Return the major index of self.

The major index of a tableau \(T\) is defined to be the sum of the number of descents of T (defined in descents()) with the sum of their legs’ lengths.

Warning

This is not to be confused with the major index of a standard tableau.

EXAMPLES:

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

If the major index would be defined in the sense of standard tableaux theory, then the following would give 3 for a result:

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

Returns a pretty print string of the tableau.

EXAMPLES:

sage: T = Tableau([[1,2,3],[3,4],[5]])
sage: T.pp()
  1  2  3
  3  4
  5
sage: Tableaux.global_options(convention="french")
sage: T.pp()
  5
  3  4
  1  2  3
sage: Tableaux.global_options.reset()
promotion(n)

Return the image of self under the promotion operator.

The promotion operator, applied to a tableau \(t\), does the following:

Iterate over all letters \(n+1\) in the tableau \(t\), from left to right. For each of these letters, do the following:

  • Remove the letter from \(t\), thus leaving a hole where it used to be.
  • Apply jeu de taquin to move this hole southwest (in French notation) until it reaches the inner boundary of \(t\).
  • Fill \(0\) into the hole once jeu de taquin has completed.

Once this all is done, add \(1\) to each letter in the tableau. This is not always well-defined. Restricted to the class of semistandard tableaux whose entries are all \(\leq n + 1\), this is the usual promotion operator defined on this class.

When self is a standard tableau of size n + 1, this definition of promotion is precisely the one given in [Hai1992] (p. 90). It is the inverse of the maps called “promotion” in [Sg2011] (p. 23) and in [St2009].

REFERENCES:

[Hai1992](1, 2, 3, 4) Mark D. Haiman, Dual equivalence with applications, including a conjecture of Proctor, Discrete Mathematics 99 (1992), 79-113, http://www.sciencedirect.com/science/article/pii/0012365X9290368P
[Sg2011](1, 2, 3, 4) Bruce E. Sagan, The cyclic sieving phenomenon: a survey, Arxiv 1008.0790v3

EXAMPLES:

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)
[[2, 3], [3]]

sage: t = Tableau([[1,1,3],[2,2]])
sage: t.promotion(2)
[[1, 2, 2], [3, 3]]

sage: t = Tableau([[1,1,3],[2,3]])
sage: t.promotion(2)
[[1, 1, 2], [2, 3]]

sage: t = Tableau([])
sage: t.promotion(2)
[]

TESTS:

We check the equivalence of two definitions of promotion on semistandard tableaux:

sage: ST = SemistandardTableaux(shape=[3,2,2,1], max_entry=6)
sage: def bk_promotion6(st):
....:     st2 = st
....:     for i in range(5, 0, -1):
....:         st2 = st2.bender_knuth_involution(i, check=False)
....:     return st2
sage: all( bk_promotion6(st) == st.promotion(5) for st in ST ) # long time
True
sage: ST = SemistandardTableaux(shape=[4,4], max_entry=6)
sage: all( bk_promotion6(st) == st.promotion(5) for st in ST ) # long time
True

We also check promotion_inverse() is the inverse of promotion():

sage: ST = SemistandardTableaux(shape=[3,2,1], max_entry=7)
sage: all( st.promotion(6).promotion_inverse(6) == st for st in ST ) # long time
True
promotion_inverse(n)

Return the image of self under the inverse promotion operator.

The inverse promotion operator, applied to a tableau \(t\), does the following:

Iterate over all letters \(1\) in the tableau \(t\), from right to left. For each of these letters, do the following:

  • Remove the letter from \(t\), thus leaving a hole where it used to be.
  • Apply jeu de taquin to move this hole northeast (in French notation) until it reaches the outer boundary of \(t\).
  • Fill \(n+2\) into the hole once jeu de taquin has completed.

Once this all is done, subtract \(1\) from each letter in the tableau. This is not always well-defined. Restricted to the class of semistandard tableaux whose entries are all \(\leq n + 1\), this is the usual inverse promotion operator defined on this class.

When self is a standard tableau of size n + 1, this definition of inverse promotion is the map called “promotion” in [Sg2011] (p. 23) and in [St2009], and is the inverse of the map called “promotion” in [Hai1992] (p. 90).

EXAMPLES:

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

sage: t = Tableau([[1,2,5],[3,3,6],[4,7]])
sage: t.promotion_inverse(8)
[[1, 2, 4], [2, 5, 9], [3, 6]]

sage: t = Tableau([])
sage: t.promotion_inverse(2)
[]

TESTS:

We check the equivalence of two definitions of inverse promotion on semistandard tableaux:

sage: ST = SemistandardTableaux(shape=[4,2,1], max_entry=7)
sage: def bk_promotion_inverse7(st):
....:     st2 = st
....:     for i in range(1, 7):
....:         st2 = st2.bender_knuth_involution(i, check=False)
....:     return st2
sage: all( bk_promotion_inverse7(st) == st.promotion_inverse(6) for st in ST ) # long time
True
sage: ST = SemistandardTableaux(shape=[2,2,2], max_entry=7)
sage: all( bk_promotion_inverse7(st) == st.promotion_inverse(6) for st in ST ) # long time
True

A test for trac ticket #13203:

sage: T = Tableau([[1]])
sage: type(T.promotion_inverse(2)[0][0])
<type 'sage.rings.integer.Integer'>
promotion_operator(i)

EXAMPLES:

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(f, *args)

EXAMPLES:

sage: from sage.combinat.tableau 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]]
reading_word_permutation(*args, **kwds)

Return the permutation obtained by reading the entries of self row by row, starting with the bottommost row (in English notation).

EXAMPLES:

sage: StandardTableau([[1,2],[3,4]]).reading_word_permutation()
[3, 4, 1, 2]

Check that trac ticket #14724 is fixed:

sage: SemistandardTableau([[1,1]]).reading_word_permutation()
[1, 2]
reduced_lambda_catabolism(part)

EXAMPLES:

sage: t = Tableau([[1,1,3,3],[2,3],[3]])
sage: t.reduced_lambda_catabolism([])
[[1, 1, 3, 3], [2, 3], [3]]
sage: t.reduced_lambda_catabolism([1])
[[1, 2, 3, 3, 3], [3]]
sage: t.reduced_lambda_catabolism([1,1])
[[1, 3, 3, 3], [3]]
sage: t.reduced_lambda_catabolism([2,1])
[[3, 3, 3, 3]]
sage: t.reduced_lambda_catabolism([4,2,1])
[]
sage: t.reduced_lambda_catabolism([5,1])
0
sage: t.reduced_lambda_catabolism([4,1])
0
reduced_lambda_katabolism(*args, **kwds)

Deprecated: Use reduced_lambda_catabolism() instead. See trac ticket #13605 for details.

restrict(n)

Return the restriction of the semistandard tableau self to n. If possible, the restricted tableau will have the same parent as this tableau.

If \(T\) is a semistandard tableau and \(n\) is a nonnegative integer, then the restriction of \(T\) to \(n\) is defined as the (semistandard) tableau obtained by removing all cells filled with entries greater than \(n\) from \(T\).

Note

If only the shape of the restriction, rather than the whole restriction, is needed, then the faster method restriction_shape() is preferred.

EXAMPLES:

sage: Tableau([[1,2],[3],[4]]).restrict(3)
[[1, 2], [3]]
sage: StandardTableau([[1,2],[3],[4]]).restrict(2)
[[1, 2]]
sage: Tableau([[1,2,3],[2,4,4],[3]]).restrict(0)
[]
sage: Tableau([[1,2,3],[2,4,4],[3]]).restrict(2)
[[1, 2], [2]]
sage: Tableau([[1,2,3],[2,4,4],[3]]).restrict(3)
[[1, 2, 3], [2], [3]]
sage: Tableau([[1,2,3],[2,4,4],[3]]).restrict(5)
[[1, 2, 3], [2, 4, 4], [3]]

If possible the restricted tableau will belong to the same category as the original tableau:

sage: S=StandardTableau([[1,2,4,7],[3,5],[6]]); S.category()
Category of elements of Standard tableaux
sage: S.restrict(4).category()
Category of elements of Standard tableaux
sage: SS=StandardTableaux([4,2,1])([[1,2,4,7],[3,5],[6]]); SS.category()
Category of elements of Standard tableaux of shape [4, 2, 1]
sage: SS.restrict(4).category()
Category of elements of Standard tableaux

sage: Tableau([[1,2],[3],[4]]).restrict(3)
[[1, 2], [3]]
sage: Tableau([[1,2],[3],[4]]).restrict(2)
[[1, 2]]
sage: SemistandardTableau([[1,1],[2]]).restrict(1)
[[1, 1]]
sage: _.category()
Category of elements of Semistandard tableaux
restriction_shape(n)

Return the shape of the restriction of the semistandard tableau self to n.

If \(T\) is a semistandard tableau and \(n\) is a nonnegative integer, then the restriction of \(T\) to \(n\) is defined as the (semistandard) tableau obtained by removing all cells filled with entries greater than \(n\) from \(T\).

This method computes merely the shape of the restriction. For the restriction itself, use restrict().

EXAMPLES:

sage: Tableau([[1,2],[2,3],[3,4]]).restriction_shape(3)
[2, 2, 1]
sage: StandardTableau([[1,2],[3],[4],[5]]).restriction_shape(2)
[2]
sage: Tableau([[1,3,3,5],[2,4,4],[17]]).restriction_shape(0)
[]
sage: Tableau([[1,3,3,5],[2,4,4],[17]]).restriction_shape(2)
[1, 1]
sage: Tableau([[1,3,3,5],[2,4,4],[17]]).restriction_shape(3)
[3, 1]
sage: Tableau([[1,3,3,5],[2,4,4],[17]]).restriction_shape(5)
[4, 3]

sage: all( T.restriction_shape(i) == T.restrict(i).shape()
....:      for T in StandardTableaux(5) for i in range(1, 5) )
True
right_key_tableau()

Return the right key tableau of self.

The right key tableau of a tableau \(T\) is a key tableau whose entries are weakly greater than the corresponding entries in \(T\), and whose column reading word is subject to certain conditions. See [LS90] for the full definition.

ALGORITHM:

The following algorithm follows [Willis10]. Note that if \(T\) is a key tableau then the output of the algorithm is \(T\).

To compute the right key tableau \(R\) of a tableau \(T\) we iterate over the columns of \(T\). Let \(T_j\) be the \(j\)-th column of \(T\) and iterate over the entires in \(T_j\) from bottom to top. Initialize the corresponding entry \(k\) in \(R\) to be the largest entry in \(T_j\). Scan the bottom of each column of \(T\) to the right of \(T_j\), updating \(k\) to be the scanned entry whenever the scanned entry is weakly greater than \(k\). Update \(T_j\) and all columns to the right by removing all scanned entries.

See also

EXAMPLES:

sage: t = Tableau([[1,2],[2,3]])
sage: t.right_key_tableau()
[[2, 2], [3, 3]]
sage: t = Tableau([[1,1,2,4],[2,3,3],[4],[5]])
sage: t.right_key_tableau()
[[2, 2, 2, 4], [3, 4, 4], [4], [5]]

TESTS:

We check that if we have a key tableau, we return the same tableau:

sage: t = Tableau([[1,1,1,2], [2,2,2], [4], [5]])
sage: t.is_key_tableau()
True
sage: t.right_key_tableau() == t
True
rotate_180()

Return the tableau obtained by rotating self by \(180\) degrees.

EXAMPLES:

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

Return the PermutationGroup corresponding to the row stabilizer of self.

This assumes that every integer from \(1\) to the size of self appears exactly once in self.

EXAMPLES:

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: PermutationGroupElement([(1,2),(3,)]) in rs
True
sage: rs.one().domain()
[1, 2, 3]
sage: rs = Tableau([[1],[2],[3]]).row_stabilizer()
sage: rs.order()
1
sage: rs = Tableau([[2,4,5],[1,3]]).row_stabilizer()
sage: rs.order()
12
sage: rs = Tableau([]).row_stabilizer()
sage: rs.order()
1
schensted_insert(i, left=False)

EXAMPLES:

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]]
schuetzenberger_involution(*args, **kwds)

Return the Schuetzenberger involution of the tableau self.

This method relies on the analogous method on words, which reverts the word and then complements all letters within the underlying ordered alphabet. If \(n\) is specified, the underlying alphabet is assumed to be \([1, 2, \ldots, n]\). If no alphabet is specified, \(n\) is the maximal letter appearing in self.

INPUT:

  • n – an integer specifying the maximal letter in the alphabet (optional)

OUTPUT:

  • a tableau, the Schuetzenberger involution of self

EXAMPLES:

sage: t = Tableau([[1,1,1],[2,2]])
sage: t.schuetzenberger_involution(3)
[[2, 2, 3], [3, 3]]

 sage: t = Tableau([[1,2,3],[4,5]])
 sage: t.schuetzenberger_involution()
 [[1, 2, 5], [3, 4]]

 sage: t = Tableau([[1,3,5,7],[2,4,6],[8,9]])
 sage: t.schuetzenberger_involution()
 [[1, 2, 6, 8], [3, 4, 9], [5, 7]]

 sage: t = Tableau([])
 sage: t.schuetzenberger_involution()
 []

 sage: t = StandardTableau([[1,2,3],[4,5]])
 sage: s = t.schuetzenberger_involution()
 sage: s.parent()
 Standard tableaux
seg()

Return the total number of segments in self, as in [S14].

Let \(T\) be a tableaux. We define a \(k\)-segment of \(T\) (in the \(i\)-th row) to be a maximal consecutive sequence of \(k\)-boxes in the \(i\)-th row for any \(i+1 \le k \le r+1\). Denote the total number of \(k\)-segments in \(T\) by \(\mathrm{seg}(T)\).

REFERENCES:

[S14](1, 2) B. Salisbury. The flush statistic on semistandard Young tableaux. Arxiv 1401.1185

EXAMPLES:

sage: t = Tableau([[1,1,2,3,5],[2,3,5,5],[3,4]])
sage: t.seg()
6

sage: B = crystals.Tableaux("A4",shape=[4,3,2,1])
sage: t = B[31].to_tableau()
sage: t.seg()
3
shape(*args, **kwds)

Return the shape of a tableau self.

EXAMPLES:

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

Return the size of the shape of the tableau self.

EXAMPLES:

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 tableau is the unit in this monoid.

See pp. 15 of [Ful1997].

EXAMPLES:

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

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).socle()
2
sage: Tableau([[1,2,3,4]]).socle()
4
standardization(check=True)

Return the standardization of self, assuming self is a semistandard tableau.

The standardization of a semistandard tableau \(T\) is the standard tableau \(\mathrm{st}(T)\) of the same shape as \(T\) whose reversed reading word is the standardization of the reversed reading word of \(T\).

The standardization of a word \(w\) can be formed by replacing all \(1\)‘s in \(w\) by \(1, 2, \ldots, k_1\) from left to right, all \(2\)‘s in \(w\) by \(k_1 + 1, k_1 + 2, \ldots, k_2\), and repeating for all letters which appear in \(w\). See also Word.standard_permutation().

INPUT:

  • check – (Default: True) Check to make sure self is semistandard. Set to False to avoid this check.

EXAMPLES:

sage: t = Tableau([[1,3,3,4],[2,4,4],[5,16]])
sage: t.standardization()
[[1, 3, 4, 7], [2, 5, 6], [8, 9]]

Standard tableaux are fixed under standardization:

sage: all((t == t.standardization() for t in StandardTableaux(6)))
True
sage: t = Tableau([])
sage: t.standardization()
[]

The reading word of the standardization is the standardization of the reading word:

sage: T = SemistandardTableaux(shape=[6,3,3,1], max_entry=5)
sage: all(t.to_word().standard_permutation() == t.standardization().reading_word_permutation() for t in T)
True
symmetric_group_action_on_entries(w)

Returns the tableau obtained form this tableau by acting by the permutation w.

Let \(T\) be a standard tableau of size \(n\), then the action of \(w \in S_n\) is defined by permuting the entries of \(T\) (recall they are \(1, 2, \ldots, n\)). In particular, suppose the entry at cell \((i, j)\) is \(a\), then the entry becomes \(w(a)\). In general, the resulting tableau \(wT\) may not be standard.

Note

This is different than symmetric_group_action_on_values() which is defined on semistandard tableaux and is guaranteed to return a semistandard tableau.

INPUT:

  • w – a permutation

EXAMPLES:

sage: StandardTableau([[1,2,4],[3,5]]).symmetric_group_action_on_entries( Permutation(((4,5))) )
[[1, 2, 5], [3, 4]]
sage: _.category()
Category of elements of Standard tableaux
sage: StandardTableau([[1,2,4],[3,5]]).symmetric_group_action_on_entries( Permutation(((1,2))) )
[[2, 1, 4], [3, 5]]
sage: _.category()
Category of elements of Tableaux
symmetric_group_action_on_values(perm)

EXAMPLES:

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_Gelfand_Tsetlin_pattern(*args, **kwds)

Return the Gelfand-Tsetlin pattern corresponding to self when semistandard.

EXAMPLES:

sage: T = Tableau([[1,2,3],[2,3],[3]])
sage: G = T.to_Gelfand_Tsetlin_pattern(); G
[[3, 2, 1], [2, 1], [1]]
sage: G.to_tableau() == T
True
sage: T = Tableau([[1,3],[2]])
sage: T.to_Gelfand_Tsetlin_pattern()
[[2, 1, 0], [1, 1], [1]]
to_chain(max_entry=None)

Return the chain of partitions corresponding to the (semi)standard tableau self.

The optional keyword parameter max_entry can be used to customize the length of the chain. Specifically, if this parameter is set to a nonnegative integer n, then the chain is constructed from the positions of the letters \(1, 2, \ldots, n\) in the tableau.

EXAMPLES:

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()
[[]]
sage: Tableau([[1,1],[2],[3]]).to_chain(max_entry=2)
[[], [2], [2, 1]]
sage: Tableau([[1,1],[2],[3]]).to_chain(max_entry=3)
[[], [2], [2, 1], [2, 1, 1]]
sage: Tableau([[1,1],[2],[3]]).to_chain(max_entry=4)
[[], [2], [2, 1], [2, 1, 1], [2, 1, 1]]
sage: Tableau([[1,1,2],[2,3],[4,5]]).to_chain(max_entry=6)
[[], [2], [3, 1], [3, 2], [3, 2, 1], [3, 2, 2], [3, 2, 2]]
to_list()

EXAMPLES:

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

Deprecated in trac ticket #14724. Use reading_word_permutation() instead.

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).to_permutation()
doctest:...: DeprecationWarning: to_permutation() is deprecated. Use instead reading_word_permutation()
See http://trac.sagemath.org/14724 for details.
[3, 4, 1, 2]
to_word()

An alias for to_word_by_row().

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).to_word()
word: 3412
sage: Tableau([[1, 4, 6], [2, 5], [3]]).to_word()
word: 325146
to_word_by_column()

Return the word obtained from a column reading of the tableau self (starting with the leftmost column, reading every column from bottom to top).

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).to_word_by_column()
word: 3142
sage: Tableau([[1, 4, 6], [2, 5], [3]]).to_word_by_column()
word: 321546
to_word_by_row()

Return the word obtained from a row reading of the tableau self (starting with the lowermost row, reading every row from left to right).

EXAMPLES:

sage: Tableau([[1,2],[3,4]]).to_word_by_row()
word: 3412
sage: Tableau([[1, 4, 6], [2, 5], [3]]).to_word_by_row()
word: 325146
up()

Deprecated in trac ticket #7983 since this is an operation on standard tableaux.

EXAMPLES:

sage: t = Tableau([[1,2]])
sage: [x for x in t.up()]
doctest:...: DeprecationWarning: Tableau.up() is deprecated since it is an operation on standard tableaux.
See http://trac.sagemath.org/7983 for details.
[[[1, 2, 3]], [[1, 2], [3]]]
up_list()

Deprecated in trac ticket #7983 since this is an operation on standard tableaux.

EXAMPLES:

sage: t = Tableau([[1,2]])
sage: t.up_list()
doctest:...: DeprecationWarning: Tableau.up_list() is deprecated since it is an operation on standard tableaux.
See http://trac.sagemath.org/7983 for details.
[[[1, 2, 3]], [[1, 2], [3]]]
vertical_flip()

Return the tableau obtained by vertically flipping the tableau self. This only works for rectangular tableaux.

EXAMPLES:

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

Return the weight of the tableau self. Trailing zeroes are omitted when returning the weight.

The weight of a tableau \(T\) is the sequence \((a_1, a_2, a_3, \ldots )\), where \(a_k\) is the number of entries of \(T\) equal to \(k\). This sequence contains only finitely many nonzero entries.

The weight of a tableau \(T\) is the same as the weight of the reading word of \(T\), for any reading order.

EXAMPLES:

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

sage: Tableau([]).weight()
[]

sage: Tableau([[1,3,3,7],[4,2],[2,3]]).weight()
[1, 2, 3, 1, 0, 0, 1]

TESTS:

We check that this agrees with going to the word:

sage: t = Tableau([[1,3,4,7],[6,2],[2,3]])
sage: def by_word(T):
....:     ed = T.to_word().evaluation_dict()
....:     m = max(ed.keys()) + 1
....:     return [ed.get(k,0) for k in range(1,m)]
sage: by_word(t) == t.weight()
True
sage: SST = SemistandardTableaux(shape=[3,1,1])
sage: all(by_word(t) == t.weight() for t in SST)
True
class sage.combinat.tableau.Tableaux

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent

A factory class for the various classes of tableaux.

INPUT:

  • n (optional) – a non-negative integer

OUTPUT:

  • If n is specified, the class of tableaux of size n. Otherwise, the class of all tableaux.

A tableau in Sage is a finite list of lists, whose lengths are weakly decreasing, or an empty list, representing the empty tableau. The entries of a tableau can be any sage object. Because of this, no enumeration through the set of Tableaux is possible.

EXAMPLES:

sage: T = Tableaux(); T
Tableaux
sage: T3 = Tableaux(3); T3
Tableaux of size 3
sage: [['a','b']] in T
True
sage: [['a','b']] in T3
False
sage: t = T3([[1,1,1]]); t
[[1, 1, 1]]
sage: t in T
True
sage: t.parent()
Tableaux of size 3
sage: T([]) # the empty tableau
[]
sage: T.category()
Category of sets

TESTS:

sage: TestSuite( Tableaux() ).run()
sage: TestSuite( Tableaux(5) ).run()
sage: t = Tableaux(3)([[1,2],[3]])
sage: t.parent()
Tableaux of size 3
sage: Tableaux(t)
Traceback (most recent call last):
...
ValueError: The argument to Tableaux() must be a non-negative integer.
sage: Tableaux(3)([[1, 1]])
Traceback (most recent call last):
...
ValueError: [[1, 1]] is not an element of Tableaux of size 3.

sage: t0 = Tableau([[1]])
sage: t1 = Tableaux()([[1]])
sage: t2 = Tableaux()(t1)
sage: t0 == t1 == t2
True
sage: t1 in Tableaux()
True
sage: t1 in Tableaux(1)
True
sage: t1 in Tableaux(2)
False

sage: [[1]] in Tableaux()
True
sage: [] in Tableaux(0)
True

Check that trac:\(14145\) has been fixed:

sage: 1 in Tableaux()
False
Element

alias of Tableau

global_options(*get_value, **set_value)

Sets the global options for elements of the tableau, skew_tableau, and tableau tuple classes. The defaults are for tableau to be displayed as a list, latexed as a Young diagram using the English convention.

OPTIONS:

  • ascii_art – (default: repr) Controls the ascii art output for tableaux
    • compact – minimal length ascii art
    • repr – display using the diagram string representation
    • table – display as a table
  • convention – (default: English) Sets the convention used for displaying tableaux and partitions
    • English – use the English convention
    • French – use the French convention
  • display – (default: list) Controls the way in which tableaux are printed
    • array – alias for diagram
    • compact – minimal length string representation
    • diagram – display as Young diagram (similar to pp()
    • ferrers_diagram – alias for diagram
    • list – print tableaux as lists
    • young_diagram – alias for diagram
  • latex – (default: diagram) Controls the way in which tableaux are latexed
    • array – alias for diagram
    • diagram – as a Young diagram
    • ferrers_diagram – alias for diagram
    • list – as a list
    • young_diagram – alias for diagram
  • notation – alternative name for convention

Note

Changing the convention for tableaux also changes the convention for partitions.

If no parameters are set, then the function returns a copy of the options dictionary.

EXAMPLES:

sage: T = Tableau([[1,2,3],[4,5]])
sage: T
[[1, 2, 3], [4, 5]]
sage: Tableaux.global_options(display="array")
sage: T
  1  2  3
  4  5
sage: Tableaux.global_options(convention="french")
sage: T
  4  5
  1  2  3

Changing the convention for tableaux also changes the convention for partitions and vice versa:

sage: P = Partition([3,3,1])
sage: print P.ferrers_diagram()
*
***
***
sage: Partitions.global_options(convention="english")
sage: print P.ferrers_diagram()
***
***
*
sage: T
  1  2  3
  4  5

The ASCII art can also be changed:

sage: t = Tableau([[1,2,3],[4,5]])
sage: ascii_art(t)
  1  2  3
  4  5
sage: Tableaux.global_options(ascii_art="normal")
sage: ascii_art(t)
+---+---+
| 4 | 5 |
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
sage: Tableaux.global_options(ascii_art="compact")
sage: ascii_art(t)
|4|5|
|1|2|3|
sage: Tableaux.global_options.reset()

See GlobalOptions for more features of these options.

class sage.combinat.tableau.Tableaux_all

Bases: sage.combinat.tableau.Tableaux

Initializes the class of all tableaux

TESTS:

sage: T = sage.combinat.tableau.Tableaux_all()
sage: TestSuite(T).run()
an_element()

Returns a particular element of the class.

TESTS:

sage: T = Tableaux()
sage: T.an_element()
[[1, 1], [1]]
class sage.combinat.tableau.Tableaux_size(n)

Bases: sage.combinat.tableau.Tableaux

Tableaux of a fixed size \(n\).

an_element()

Returns a particular element of the class.

TESTS:

sage: T = sage.combinat.tableau.Tableaux_size(3)
sage: T.an_element()
[[1, 1], [1]]
sage: T = sage.combinat.tableau.Tableaux_size(0)
sage: T.an_element()
[]
sage.combinat.tableau.from_chain(chain)

Returns a semistandard tableau from a chain of partitions.

EXAMPLES:

sage: from sage.combinat.tableau import from_chain
sage: from_chain([[], [2], [2, 1], [3, 2, 1]])
[[1, 1, 3], [2, 3], [3]]
sage.combinat.tableau.from_shape_and_word(shape, w, convention='French')

Returns a tableau from a shape and word.

INPUT:

  • shape – a partition
  • w – a word whose length equals that of the partition
  • convention – a string which can take values "French" or "English"; the default is "French"

OUTPUT:

A tableau, whose shape is shape and whose reading word is w. If the convention is specified as "French", the reading word is to be read starting from the top row in French convention (= the bottom row in English convention). If the convention is specified as "English", the reading word is to be read starting with the top row in English convention.

EXAMPLES:

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
word: 4213
sage: from_shape_and_word(shape, word)
[[1, 3], [2], [4]]
sage: word = Word(flatten(t))
sage: from_shape_and_word(shape, word, convention = "English")
[[1, 3], [2], [4]]
sage.combinat.tableau.symmetric_group_action_on_values(word, perm)

EXAMPLES:

sage: from sage.combinat.tableau import symmetric_group_action_on_values
sage: symmetric_group_action_on_values([1,1,1],[1,3,2])
[1, 1, 1]
sage: symmetric_group_action_on_values([1,1,1],[2,1,3])
[2, 2, 2]
sage: symmetric_group_action_on_values([1,2,1],[2,1,3])
[2, 2, 1]
sage: symmetric_group_action_on_values([2,2,2],[2,1,3])
[1, 1, 1]
sage: symmetric_group_action_on_values([2,1,2],[2,1,3])
[2, 1, 1]
sage: symmetric_group_action_on_values([2,2,3,1,1,2,2,3],[1,3,2])
[2, 3, 3, 1, 1, 2, 3, 3]
sage: symmetric_group_action_on_values([2,1,1],[2,1])
[2, 1, 2]
sage: symmetric_group_action_on_values([2,2,1],[2,1])
[1, 2, 1]
sage: symmetric_group_action_on_values([1,2,1],[2,1])
[2, 2, 1]
sage.combinat.tableau.unmatched_places(w, open, close)

EXAMPLES:

sage: from sage.combinat.tableau import unmatched_places
sage: unmatched_places([2,2,2,1,1,1],2,1)
([], [])
sage: unmatched_places([1,1,1,2,2,2],2,1)
([0, 1, 2], [3, 4, 5])
sage: unmatched_places([], 2, 1)
([], [])
sage: unmatched_places([1,2,4,6,2,1,5,3],2,1)
([0], [1])
sage: unmatched_places([2,2,1,2,4,6,2,1,5,3], 2, 1)
([], [0, 3])
sage: unmatched_places([3,1,1,1,2,1,2], 2, 1)
([1, 2, 3], [6])

Previous topic

Tableaux and Tableaux-like Objects

Next topic

Skew Tableaux

This Page