TableauTuples

A TableauTuple is a tuple of tableaux. These objects arise naturally in representation theory of the wreath products of cyclic groups and the symmetric groups where the standard tableau tulpes index bases for the ordinary irreducible representations. This generalises the well-known fact the ordinary irreducible representations of the symmetric groups have bases indexed by the standard tableaux of a given shape. More generally, TableauTuples, or multitableaux, appear in the representation theory of the degenerate and non-degenerate cyclotomic Hecke algebras and in the crystal theory of the integral highest weight representations of the affine special linear groups.

A TableauTuple is an ordered tuple \((t^{(1)}, t^{(2)}, \ldots, t^{(l)})\) of tableaux. The length of the tuple is its level and the tableaux \(t^{(1)}, t^{(2)}, \ldots, t^{(l)}\) are the components of the TableauTuple.

A tableaux can be thought of as the labelled diagram of a partition. Analogously, a TableauTuple is the labelled diagram of a PartitionTuple. That is, a TableauTuple is a tableau of PartitionTuple shape. As much as possible, TableauTuples behave in exactly the same way as Tableaux. There are obvious differences in that the cells of a partition are ordered pairs \((r, c)\), where \(r\) is a row index and \(c\) a column index, whereas the cells of a PartitionTuple are ordered triples \((k, r, c)\), with \(r\) and \(c\) as before and \(k\) indexes the component.

Frequently, we will call a TableauTuple a tableau, or a tableau of PartitionTuple shape. If the shape of the tableau is known this should not cause any confusion.

Warning

In sage the convention is that the \((k, r, c)\)-th entry of a tableau tuple \(t\) is the entry in row \(r\), column \(c\) and component \(k\) of the tableau. This is because it makes much more sense to let t[k] be component of the tableau. In particular, we want t(k,r,c) == t[k][r][c]. In the literature, the cells of a tableau tuple are usually written in the form \((r, c, k)\), where \(r\) is the row index, \(c\) is the column index, and \(k\) is the component index.

The same convention applies to the cells of PartitionTuples.

Note

As with partitions and tableaux, the cells are 0-based. For example, the (lexicographically) first cell in any non-empty tableau tuple is [0,0,0].

EXAMPLES:

sage: TableauTuple([[1,2,3],[4,5]])
[[1, 2, 3], [4, 5]]
sage: t=TableauTuple([ [[6,7],[8,9]],[[1,2,3],[4,5]] ]); t
([[6, 7], [8, 9]], [[1, 2, 3], [4, 5]])
sage: t.pp()
     6  7     1  2  3
     8  9     4  5
sage: t(0,0,1)
7
sage: t(1,0,1)
2
sage: t.shape()
([2, 2], [3, 2])
sage: t.size()
9
sage: t.level()
2
sage: t.components()
[[[6, 7], [8, 9]], [[1, 2, 3], [4, 5]]]
sage: t.entries()
[6, 7, 8, 9, 1, 2, 3, 4, 5]
sage: t.parent()
Tableau tuples
sage: t.category()
Category of elements of Tableau tuples

One reason for implementing TableauTuples is to be able to consider StandardTableauTuples. These objects arise in many areas of algebraic combinatorics. In particular, they index bases for the Specht modules of the cyclotomic Hecke algebras of type \(G(r,1,n)\). A StandardTableauTuple of tableau whose entries are increasing along rows and down columns in each component and which contain the numbers \(1,2, \ldots, n\), where the shape of the StandardTableauTuple is a PartitionTuple of \(n\).

sage: s = StandardTableauTuple([ [[1,2],[3]],[[4,5]]])
sage: s.category()
Category of elements of Standard tableau tuples
sage: t = TableauTuple([ [[1,2],[3]],[[4,5]]])
sage: t.is_standard(), t.is_column_strict(), t.is_row_strict()
(True, True, True)
sage: t.category()
Category of elements of Tableau tuples
sage: s == t
True
sage: s is t
False
sage: s == StandardTableauTuple(t)
True
sage: StandardTableauTuples([ [2,1],[1] ])[:]
[([[1, 2], [3]], [[4]]),
 ([[1, 3], [2]], [[4]]),
 ([[1, 2], [4]], [[3]]),
 ([[1, 3], [4]], [[2]]),
 ([[2, 3], [4]], [[1]]),
 ([[1, 4], [2]], [[3]]),
 ([[1, 4], [3]], [[2]]),
 ([[2, 4], [3]], [[1]])]

As tableaux (of partition shape) are in natural bijection with 1-tuples of tableaux all of the TableauTuple classes return an ordinary Tableau when given TableauTuple of level 1.

sage: TableauTuples( level=1 ) is Tableaux()
True
sage: TableauTuple([[1,2,3],[4,5]])
[[1, 2, 3], [4, 5]]
sage: TableauTuple([ [[1,2,3],[4,5]] ])
[[1, 2, 3], [4, 5]]
sage: TableauTuple([[1,2,3],[4,5]]) == Tableau([[1,2,3],[4,5]])
True

There is one situation where a 1-tuple of tableau is not actually a Tableau; tableaux generated by the StandardTableauTuples() iterators must have the correct parents, so in this one case 1-tuples of tableaux are different from Tableaux:

sage: StandardTableauTuples()[:10]
[(),
 ([[1]]),
 ([], []),
 ([[1, 2]]),
 ([[1], [2]]),
 ([[1]], []),
 ([], [[1]]),
 ([], [], []),
 ([[1, 2, 3]]),
 ([[1, 3], [2]])]

AUTHORS:

  • Andrew Mathas (2012-10-09): Initial version – heavily based on tableau.py by Mike Hansen (2007) and Jason Bandlow (2011).

This file consists of the following major classes:

Element classes:

Factory classes:

Parent classes:

Todo

Implement semistandard tableau tuples as defined in [DJM].

Much of the combinatorics implemented here is motivated by this and subsequent papers on the representation theory of these algebras.

REFERENCES:

[DJM](1, 2) R. Dipper, G. James and A. Mathas “The cyclotomic q-Schur algebra”, Math. Z, 229 (1999), 385-416.
[BK]J. Brundan and A. Kleshchev “Graded decomposition numbers for cyclotomic Hecke algebras”, Adv. Math., 222 (2009), 1883-1942”
class sage.combinat.tableau_tuple.StandardTableauTuple(parent, t)

Bases: sage.combinat.tableau_tuple.TableauTuple

A class to model a standard tableau of shape a partition tuple. This is a tuple of standard tableau with entries \(1, 2, \ldots, n\), where \(n\) is the size of the underlying partition tuple, such that the entries increase along rows and down columns in each component of the tuple.

Note

The tableaux appearing in a StandardTableauTuple are both row and column strict, but individually they are not standard tableaux because the entries in any single component of a StandardTableauTuple will typically not be in bijection with \(\{1, 2, \ldots, n\}\).

INPUT:

  • t – a tableau, a list of (standard) tableau or an equivalent list

OUTPUT:

Note

Sage uses the English convention for (tuples of) partitions and tableaux: the longer rows are displayed on top. As with PartitionTuple, in sage the cells, or nodes, of partition tuples are 0-based. For example, the (lexicographically) first cell in any non-empty partition tuple is \([0,0,0]\). Further, the coorindates [k,r,c] in a TableauTuple refer to the component, row and column indices, respectively.

EXAMPLES:

sage: t=TableauTuple([ [[1,3,4],[7,9]], [[2,8,11],[6]], [[5,10]] ]); t
([[1, 3, 4], [7, 9]], [[2, 8, 11], [6]], [[5, 10]])
sage: t[0][0][0]
1
sage: t[1][1][0]
6
sage: t[2][0][0]
5
sage: t[2][0][1]
10

sage: t = StandardTableauTuple([[[4,5],[7]],[[1,2,3],[6,8]],[[9]]]); t
([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])
sage: t.pp()
 4  5     1  2  3     9
 7        6  8
sage: t.shape()
([2, 1], [3, 2], [1])
sage: t[0].pp() # pretty print
4 5
7
sage: t.is_standard()
True
sage: t[0].is_standard()
False
sage: StandardTableauTuple([[],[],[]]) # An empty tableau tuple
([], [], [])

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

sage: STT = StandardTableauTuples()
sage: STT([[[4,5],[7]],[[1,2,3],[6,8]],[[9]]])
([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])

TESTS:

sage: StandardTableauTuple( [[1,2,3],[4,5]] ).category()  # indirect doctest
Category of elements of Standard tableaux
sage: StandardTableauTuple([[[1,2,3],[4,5]]]).category()  # indirect doctest
Category of elements of Standard tableaux
sage: StandardTableauTuples()([[[1,2,3],[4,5]]]).category()  # indirect doctest
Category of elements of Standard tableaux

sage: StandardTableauTuple([[[1,2,3]],[[1]]])
Traceback (most recent call last):
...
ValueError: entries must be in bijection with {1,2,...,n}

sage: StandardTableauTuple([[],[[1,2,1]]])
Traceback (most recent call last):
...
ValueError: tableaux must be row strict

sage: StandardTableauTuple([ [[1,2,4],[6]],[[0,1]],[[10]] ])
Traceback (most recent call last):
...
ValueError: entries must be in bijection with {1,2,...,n}

sage: TestSuite(  StandardTableauTuple([[[1,3,4],[6]],[[2],[5]]]) ).run()
sage: TestSuite(  StandardTableauTuple([[[1,3,4],[6]],[], [[2],[5]]]) ).run()
sage: TestSuite(  StandardTableauTuple([[[1,3,4],[6]],[[7]], [[2],[5]]]) ).run()
content(k, multicharge)

Return the content k in self.

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\) + multicharge[k].

The multicharge = \([m_1, \ldots, m_l]\) determines the dominant weight

\[\Lambda = \sum_{i=1}^l \Lambda_{a_i}\]

of the affine special linear group. In the combinatorics, the muticharge simply offsets the contents in each component so that the cell \((k, r, c)\) has content \(a_k+c-r\).

INPUT:

  • k – An integer with \(1 \leq k \leq n\)
  • multicharge – a sequence of integers of length \(l\).

Here \(l\) is the level() and \(n\) is the size() of self.

EXAMPLES:

sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(3,[0,0])
-1
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(3,[0,1])
0
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(3,[0,2])
1
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(6,[0,2])
Traceback (most recent call last):
...
ValueError: 6 must be contained in the tableaux
dominates(t)

Returns True if the tableau (tuple) self dominates the tableau t. The two tableaux do not need to be of the same shape.

EXAMPLES:

sage: s=StandardTableauTuple([[1,2,3],[4,5]])
sage: t=StandardTableauTuple([[1,2],[3,5],[4]])
sage: s.dominates(t)
True
sage: t.dominates(s)
False
inverse(k)

Return the cell containing k in the tableau tuple self.

EXAMPLES:

sage: StandardTableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(1)
(0, 0, 0)
sage: StandardTableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(2)
(0, 0, 1)
sage: StandardTableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(3)
(0, 1, 0)
sage: StandardTableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(12)
(2, 2, 0)
restrict(m=None)

Returns the restriction of the standard tableau self to m, which defaults to one less than the current size().

EXAMPLES:

sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(6)
([[5]], [[1, 2], [3, 4]])
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(5)
([[5]], [[1, 2], [3, 4]])
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(4)
([], [[1, 2], [3, 4]])
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3)
([], [[1, 2], [3]])
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(2)
([], [[1, 2]])
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(1)
([], [[1]])
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(0)
([], [])

Where possible the restricted tableau belongs to the same category as the tableau self:

sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3).category()
Category of elements of Tableau tuples
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3).category()
Category of elements of Standard tableau tuples
sage: StandardTableauTuples([[1],[2,2]])([[[5]],[[1,2],[3,4]]]).restrict(3).category()
Category of elements of Standard tableau tuples
sage: StandardTableauTuples(level=2)([[[5]],[[1,2],[3,4]]]).restrict(3).category()
Category of elements of Standard tableau tuples of level 2
to_chain()

Returns the chain of partitions corresponding to the standard tableau tuple self.

EXAMPLES:

sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).to_chain()
[([], []),
  ([], [1]),
  ([], [2]),
  ([], [2, 1]),
  ([], [2, 2]),
  ([1], [2, 2])]
class sage.combinat.tableau_tuple.StandardTableauTuples

Bases: sage.combinat.tableau_tuple.TableauTuples

A factory class for the various classes of tuples of standard tableau.

INPUT:

There are three optional arguments:

  • level – The level() of the tuples of tableaux
  • size – The size() of the tuples of tableaux
  • shape – A list or a partition tuple specifying the shape() of the standard tableau tuples

It is not necessary to use the keywords. If they are not used then then first integer argument specifies the level() and the second the size() of the tableau tuples.

OUTPUT:

The appropriate subclass of StandardTableauTuples.

A tuple of standard tableau is a tableau whose entries are positive integers which increase from left to down along the rows, and from top to bottom down the columns, in each component. The entries do NOT need to increase from left to right along the components.

Note

Sage uses the English convention for (tuples of) partitions and tableaux: the longer rows are displayed on top. As with PartitionTuple, in sage the cells, or nodes, of partition tuples are 0-based. For example, the (lexicographically) first cell in any non-empty partition tuple is \([0,0,0]\).

EXAMPLES:

sage: tabs=StandardTableauTuples([[2],[1],[1,1]]); tabs
Standard tableau tuples of shape ([2], [1], [1, 1])
sage: tabs.cardinality()
30
sage: tabs.list()
[([[1, 2]], [[3]], [[4], [5]]),
 ([[1, 3]], [[2]], [[4], [5]]),
 ([[2, 3]], [[1]], [[4], [5]]),
 ([[1, 2]], [[4]], [[3], [5]]),
 ([[1, 3]], [[4]], [[2], [5]]),
 ([[2, 3]], [[4]], [[1], [5]]),
 ([[1, 4]], [[2]], [[3], [5]]),
 ([[2, 4]], [[1]], [[3], [5]]),
 ([[1, 4]], [[3]], [[2], [5]]),
 ([[2, 4]], [[3]], [[1], [5]]),
 ([[3, 4]], [[1]], [[2], [5]]),
 ([[3, 4]], [[2]], [[1], [5]]),
 ([[1, 2]], [[5]], [[3], [4]]),
 ([[1, 3]], [[5]], [[2], [4]]),
 ([[2, 3]], [[5]], [[1], [4]]),
 ([[1, 4]], [[5]], [[2], [3]]),
 ([[2, 4]], [[5]], [[1], [3]]),
 ([[3, 4]], [[5]], [[1], [2]]),
 ([[1, 5]], [[2]], [[3], [4]]),
 ([[2, 5]], [[1]], [[3], [4]]),
 ([[1, 5]], [[3]], [[2], [4]]),
 ([[2, 5]], [[3]], [[1], [4]]),
 ([[3, 5]], [[1]], [[2], [4]]),
 ([[3, 5]], [[2]], [[1], [4]]),
 ([[1, 5]], [[4]], [[2], [3]]),
 ([[2, 5]], [[4]], [[1], [3]]),
 ([[3, 5]], [[4]], [[1], [2]]),
 ([[4, 5]], [[1]], [[2], [3]]),
 ([[4, 5]], [[2]], [[1], [3]]),
 ([[4, 5]], [[3]], [[1], [2]])]

sage: tabs=StandardTableauTuples(level=3); tabs
Standard tableau tuples of level 3
sage: tabs[100]
([[1, 2], [3]], [], [[4]])

sage: StandardTableauTuples()[0]
()

TESTS:

sage: TestSuite( StandardTableauTuples() ).run()
sage: TestSuite( StandardTableauTuples(level=1) ).run()
sage: TestSuite( StandardTableauTuples(level=4) ).run()
sage: TestSuite( StandardTableauTuples(size=0) ).run(max_runs=50) # recursion depth exceeded with default max_runs
sage: TestSuite( StandardTableauTuples(size=6) ).run()
sage: TestSuite( StandardTableauTuples(level=1, size=0) ).run()
sage: TestSuite( StandardTableauTuples(level=1, size=0) ).run()
sage: TestSuite( StandardTableauTuples(level=1, size=10) ).run()
sage: TestSuite( StandardTableauTuples(level=4, size=0) ).run()
sage: TestSuite( StandardTableauTuples(level=4, size=0) ).run()
sage: TestSuite( StandardTableauTuples(level=4, size=10) ).run() # long time
sage: TestSuite( StandardTableauTuples(shape=[[1],[3,1],[],[2,1]]) ).run()
Element

alias of StandardTableauTuple

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: StandardTableauTuples().an_element()
([[1]], [[2, 3]], [[4, 5, 6, 7]])
level_one_parent_class

alias of StandardTableaux_all

shape()

Return the shape of the set of StandardTableauTuples, or None if it is not defined.

EXAMPLES:

sage: tabs=StandardTableauTuples(shape=[[5,2],[3,2],[],[1,1,1],[3]]); tabs
Standard tableau tuples of shape ([5, 2], [3, 2], [], [1, 1, 1], [3])
sage: tabs.shape()
([5, 2], [3, 2], [], [1, 1, 1], [3])
sage: StandardTableauTuples().shape() is None
True
class sage.combinat.tableau_tuple.StandardTableauTuples_all

Bases: sage.combinat.tableau_tuple.StandardTableauTuples

Default class of all StandardTableauTuples with an arbitrary level() and size().

class sage.combinat.tableau_tuple.StandardTableauTuples_level(level)

Bases: sage.combinat.tableau_tuple.StandardTableauTuples

Class of all StandardTableauTuples with a fixed level and arbitrary size.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: StandardTableauTuples(2).an_element()
([[1]], [[2, 3]])
sage: StandardTableauTuples(3).an_element()
([[1]], [[2, 3]], [[4, 5, 6, 7]])
class sage.combinat.tableau_tuple.StandardTableauTuples_level_size(level, size)

Bases: sage.combinat.tableau_tuple.StandardTableauTuples

Class of all StandardTableauTuples with a fixed level and a fixed size.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: StandardTableauTuples(5,size=2).an_element()
([], [], [], [], [[1], [2]])
sage: StandardTableauTuples(2,size=4).an_element()
([[1]], [[2, 3], [4]])
cardinality()

Returns the number of elements in this set of tableaux.

EXAMPLES:

sage: StandardTableauTuples(3,2).cardinality()
12
sage: StandardTableauTuples(4,6).cardinality()
31936
class sage.combinat.tableau_tuple.StandardTableauTuples_shape(shape)

Bases: sage.combinat.tableau_tuple.StandardTableauTuples

Class of all StandardTableauTuples of a fixed shape.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: StandardTableauTuples([[2],[2,1]]).an_element()
([[2, 4]], [[1, 3], [5]])
sage: StandardTableauTuples([[10],[],[]]).an_element()
([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [], [])
cardinality()

Returns the number of standard Young tableau tuples of with the same shape as the partition tuple self.

Let \(\mu=(\mu^{(1)},\dots,\mu^{(l)})\) be the shape of the tableaux in self and let \(m_k=|\mu^{(k)}|\), for \(1\le k\le l\). Multiplying by a (unique) coset representative of the Young subgroup \(S_{m_1}\times\dots\times S_{m_l}\) inside the symmetric group \(S_n\), we can assume that \(t\) is standard and the numbers \(1,2...,n\) are entered in order from to right along the components of the tableau. Therefore, there are

\[\binom{n}{m_1,\dots,m_l}\prod_{k=1}^l |\text{Std}(\mu^{(k)})|\]

standard tableau tuples of this shape, where \(|\text{Std}(\mu^{(k)})|\) is the number of standard tableau of shape \(\mu^{(k)}\), for \(1 \leq k \leq l\). This is given by the hook length formula.

EXAMPLES:

sage: StandardTableauTuples([[3,2,1],[]]).cardinality()
16
sage: StandardTableauTuples([[1],[1],[1]]).cardinality()
6
sage: StandardTableauTuples([[2,1],[1],[1]]).cardinality()
40
sage: StandardTableauTuples([[3,2,1],[3,2]]).cardinality()
36960
last()

Returns the last standard tableau tuple in self, with respect to the order that they are generated by the iterator. This is just the standard tableau tuple with the numbers \(1,2, \ldots, n\), where \(n\) is size(), entered in order down the columns form right to left along the components.

EXAMPLES:

sage: t=StandardTableauTuples([[2],[2,2]]).last().pp()
    5  6     1  3
             2  4
random_element()

Returns a random standard tableau in self.

We do this by randomly selecting addable nodes to place \(1, 2, \ldots, n\). Of course we could do this recursively, but it’s more efficient to keep track of the (changing) list of addable nodes as we go.

EXAMPLES:

sage: StandardTableauTuples([[2],[2,1]]).random_element()  # random
([[1, 2]], [[3, 4], [5]])
class sage.combinat.tableau_tuple.StandardTableauTuples_size(size)

Bases: sage.combinat.tableau_tuple.StandardTableauTuples

Class of all StandardTableauTuples with an arbitrary level and a fixed size.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: StandardTableauTuples(size=2).an_element()
([[1]], [[2]], [], [])
sage: StandardTableauTuples(size=4).an_element()
([[1]], [[2, 3, 4]], [], [])
class sage.combinat.tableau_tuple.TableauTuple(parent, t)

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

A class to model a tuple of tableaux.

INPUT:

  • t – a list or tuple of Tableau, a list or tuple of lists of lists

OUTPUT:

  • The Tableau tuple object constructed from t.

A TableauTuple is a tuple of tableau of shape a PartitionTuple. These combinatorial objects are useful is several areas of algebraic combinatorics. In particular, they are important in:

  • the representation theory of the complex reflection groups of type \(G(l,1,n)\) and the representation theory of the associated (degenerate and non-degenerate) Hecke algebras. See, for example, [DJM]
  • the crystal theory of (quantum) affine special linear groups and its integral highest weight modules and their canonical bases. See, for example, [BK].

These apparently different and unrelated contexts are, in fact, intimately related as in characteristic zero the cyclotomic Hecke algebras categorify the canonical bases of the integral highest weight modules of the quantum affine special linear groups.

The level() of a tableau tuple is the length of the tuples. This corresponds to the level of the corresponding highest weight module.

In sage a TableauTuple looks an behaves like a real tuple of (level 1) Tableaux. Many of the operations which are defined on Tableau extend to TableauTuples. Tableau tulpes of level 1 are just ordinary Tableau.

In sage, the entries of Tableaux can be very general, including arbitrarily nested lists, so some lists can be interpreted either as a tuple of tableaux or simply as tableaux. If it is possible to interpret the input to TableauTuple as a tuple of tableaux then TableauTuple returns the corresponding tuple. Given a 1-tulpe of tableaux the tableau itself is returned.

EXAMPLES:

sage: t = TableauTuple([ [[6,9,10],[11]],[[1,2,3],[4,5]],[[7],[8]] ]); t
([[6, 9, 10], [11]], [[1, 2, 3], [4, 5]], [[7], [8]])
sage: t.level()
3
sage: t.size()
11
sage: t.shape()
([3, 1], [3, 2], [1, 1])
sage: t.is_standard()
True
sage: t.pp() # pretty print
6  9 10     1  2  3     7
11          4  5        8
sage: t.category()
Category of elements of Tableau tuples
sage: t.parent()
Tableau tuples

sage: s = TableauTuple([ [['a','c','b'],['d','e']],[[(2,1)]]]); s
([['a', 'c', 'b'], ['d', 'e']], [[(2, 1)]])
sage: s.shape()
([3, 2], [1])
sage: s.size()
6

sage: TableauTuple([[],[],[]])  # The empty 3-tuple of tableaux
([], [], [])

sage: TableauTuple([[1,2,3],[4,5]])
[[1, 2, 3], [4, 5]]
sage: TableauTuple([[1,2,3],[4,5]]) == Tableau([[1,2,3],[4,5]])
True

TESTS:

sage: TableauTuple( [[1,2,3],[4,5]] ).category()
Category of elements of Tableaux
sage: TableauTuple([[[1,2,3],[4,5]]]).category()
Category of elements of Tableaux

sage: TableauTuple([[1],[2,3]])
Traceback (most recent call last):
...
ValueError: A tableau must be a list of lists.

sage: TestSuite( TableauTuple([ [[1,2],[3,4]], [[1,2],[3,4]] ]) ).run()
sage: TestSuite( TableauTuple([ [[1,2],[3,4]], [], [[1,2],[3,4]] ]) ).run()
sage: TestSuite( TableauTuple([[[1,1],[1]],[[1,1,1]],[[1],[1],[1]],[[1]]]) ).run()
Element

alias of Tableau

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=StandardTableauTuple([ [[3,4,7],[6,8]], [[9,13],[12]], [[1,5],[2,11],[10]] ]); s.pp()
     3  4  7     9 13     1  5
     6  8       12        2 11
                         10
sage: t=s.add_entry( (0,0,3),14); t.pp(); t.category()
     3  4  7 14     9 13     1  5
     6  8          12        2 11
                            10
Category of elements of Standard tableau tuples
sage: t=s.add_entry( (0,0,3),15); t.pp(); t.category()
     3  4  7 15     9 13     1  5
     6  8          12        2 11
                            10
Category of elements of Tableau tuples
sage: t=s.add_entry( (1,1,1),14); t.pp(); t.category()
     3  4  7     9 13     1  5
     6  8       12 14     2 11
                         10
Category of elements of Standard tableau tuples
sage: t=s.add_entry( (2,1,1),14); t.pp(); t.category()
     3  4  7     9 13     1  5
     6  8       12        2 14
                         10
Category of elements of Tableau tuples
sage: t=s.add_entry( (2,1,2),14); t.pp(); t.category()
Traceback (most recent call last):
...
IndexError: (2, 1, 2) is not an addable cell of the tableau
cells_containing(m)

Returns the list of cells in which the letter m appears in the tableau self.

The list is ordered with cells appearing from left to right.

EXAMPLES:

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

Return the charge of the reading word of self.

See charge() for more information.

EXAMPLES:

sage: TableauTuple([[[4,5]],[[1,1,2,4],[2,4,4],[4]],[[1,3,4],[3,4]]]).charge()
4
cocharge()

Return the cocharge of the reading word of self.

See cocharge() for more information.

EXAMPLES:

sage: TableauTuple([[[4,5]],[[1,1,2,4],[2,4,4],[4]],[[1,3,4],[3,4]]]).charge()
4
column_stabilizer()

Return the PermutationGroup corresponding to self. That is, return subgroup of the symmetric group of degree size() which is the column stabilizer of self.

EXAMPLES:

sage: cs = TableauTuple([[[1,2,3],[4,5]],[[6,7]],[[8],[9]]]).column_stabilizer()
sage: cs.order()
8
sage: PermutationGroupElement([(1,3,2),(4,5)]) in cs
False
sage: PermutationGroupElement([(1,4)]) in cs
True
components()

Return a list of the components of tableau tuple self. The \(components\) are the individual Tableau which are contained in the tuple self.

For compatibility with TableauTuples of level() 1, components() should be used to iterate over the components of TableauTuples.

EXAMPLES:

sage: for t in TableauTuple([[1,2,3],[4,5]]).components(): t.pp()
  1  2  3
  4  5
sage: for t in TableauTuple([ [[1,2,3],[4,5]], [[6,7],[8,9]] ]).components(): t.pp()
  1  2  3
  4  5
  6  7
  8  9
conjugate()

Returns the conjugate of the tableau tuple self. That is, the TableauTuple obtained from self by reversing the order of the components and conjugating each component – that is, swapping the rows and columns of the all of Tableau in self (see sage.combinat.tableau.Tableau.conjugate()).

EXAMPLES:

sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).conjugate()
([[9, 11, 12], [10]], [[5, 8], [6], [7]], [[1, 3], [2, 4]])
entries()

Returns a sorted list of all entries of self, in the order obtained by reading across the rows.

EXAMPLES:

sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).entries()
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
sage: TableauTuple([[[1,2],[3,4]],[[9,10],[11],[12]],[[5,6,7],[8]]]).entries()
[1, 2, 3, 4, 9, 10, 11, 12, 5, 6, 7, 8]
entry(l, r, c)

Returns the entry of the cell (l, r, c) in self.

A cell is a tuple (l, r, c) of coordinates, where l is the component index, r is the row index, and c is the column index.

EXAMPLES:

sage: t = TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]])
sage: t.entry(1, 0, 0)
5
sage: t.entry(1, 1, 1)
Traceback (most recent call last):
...
IndexError: list index out of range
is_column_strict()

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

A tableau tuple is column strict if the entries in each column of each component are in increasing order, when read from top to bottom.

EXAMPLES:

sage: TableauTuple([[[5,7],[8]],[[1, 3], [2, 4]],[[6]]]).is_column_strict()
True
sage: TableauTuple([[[1, 2], [2, 4]],[[4,5,6],[7,8]]]).is_column_strict()
True
sage: TableauTuple([[[1]],[[2, 3], [2, 4]]]).is_column_strict()
False
sage: TableauTuple([[[1]],[[2, 2], [4,5]]]).is_column_strict()
True
sage: TableauTuple([[[1,2],[6,7]],[[4,8], [6, 9]],[]]).is_column_strict()
True
is_row_strict()

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

A tableau tuple is row strict if the entries in each row of each component are in increasing order, when read from left to right.

EXAMPLES:

sage: TableauTuple([[[5,7],[8]],[[1, 3], [2, 4]],[[6]]]).is_row_strict()
True
sage: TableauTuple([[[1, 2], [2, 4]],[[4,5,6],[7,8]]]).is_row_strict()
True
sage: TableauTuple([[[1]],[[2, 3], [2, 4]]]).is_row_strict()
True
sage: TableauTuple([[[1]],[[2, 2], [4,5]]]).is_row_strict()
False
sage: TableauTuple([[[1,2],[6,7]],[[4,8], [6, 9]],[]]).is_row_strict()
True
is_standard()

Returns True if the tableau self is a standard tableau and False otherwise.

A tableau tuple is standard if it is row standard, column standard and the entries in the tableaux are \(1, 2, \ldots, n\), where \(n\) is the size() of the underlying partition tuple of self.

EXAMPLES:

sage: TableauTuple([[[5,7],[8]],[[1, 3], [2, 4]],[[6]]]).is_standard()
True
sage: TableauTuple([[[1, 2], [2, 4]],[[4,5,6],[7,8]]]).is_standard()
False
sage: TableauTuple([[[1]],[[2, 3], [2, 4]]]).is_standard()
False
sage: TableauTuple([[[1]],[[2, 2], [4,5]]]).is_row_strict()
False
sage: TableauTuple([[[1,2],[6,7]],[[4,8], [6, 9]],[]]).is_standard()
False
level()

Return the level of the tableau self, which is just the number of components in the tableau tuple self.

EXAMPLES:

sage: TableauTuple([[[7,8,9]],[],[[1,2,3],[4,5],[6]]]).level()
3
pp()

Pretty printing for the tableau tuple self.

EXAMPLES:

sage: TableauTuple([ [[1,2,3],[4,5]], [[1,2,3],[4,5]] ]).pp()
    1  2  3     1  2  3
    4  5        4  5
sage: TableauTuple([ [[1,2],[3],[4]],[],[[6,7,8],[10,11],[12],[13]]]).pp()
    1  2   -     6  7  8
    3           10 11
    4           12
                13
sage: t = TableauTuple([ [[1,2,3],[4,5],[6],[9]], [[1,2,3],[4,5,8]], [[11,12,13],[14]] ])
sage: t.pp()
    1  2  3     1  2  3    11 12 13
    4  5        4  5  8    14
    6
    9
sage: TableauTuples.global_options(convention="french")
sage: t.pp()
     9
     6
     4  5        4  5  8    14
     1  2  3     1  2  3    11 12 13
sage: TableauTuples.global_options.reset()
restrict(m=None)

Returns the restriction of the standard tableau self to m.

The restriction is the subtableau of self whose entries are less than or equal to m.

By default, m is one less than the current size.

EXAMPLES:

sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict()
([], [[1, 2], [3, 4]])
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(6)
([[5]], [[1, 2], [3, 4]])
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(5)
([[5]], [[1, 2], [3, 4]])
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(4)
([], [[1, 2], [3, 4]])
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3)
([], [[1, 2], [3]])
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(2)
([], [[1, 2]])
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(1)
([], [[1]])
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(0)
([], [])

Where possible the restricted tableau belongs to the same category as the original tableaux:

sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3).category()
Category of elements of Tableau tuples
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3).category()
Category of elements of Tableau tuples
sage: TableauTuples(level=2)([[[5]],[[1,2],[3,4]]]).restrict(3).category()
Category of elements of Tableau tuples of level 2
row_stabilizer()

Return the PermutationGroup corresponding to self. That is, return subgroup of the symmetric group of degree size() which is the row stabilizer of self.

EXAMPLES:

sage: rs = TableauTuple([[[1,2,3],[4,5]],[[6,7]],[[8],[9]]]).row_stabilizer()
sage: rs.order()
24
sage: PermutationGroupElement([(1,3,2),(4,5)]) in rs
True
sage: PermutationGroupElement([(1,4)]) in rs
False
sage: rs.one().domain()
[1, 2, 3, 4, 5, 6, 7, 8, 9]
shape()

Returns the PartitionTuple which is the shape of the tableau tuple self.

EXAMPLES:

sage: TableauTuple([[[7,8,9]],[],[[1,2,3],[4,5],[6]]]).shape()
([3], [], [3, 2, 1])
size()

Returns the size of the tableau tuple self, which is just the number of boxes, or the size, of the underlying PartitionTuple.

EXAMPLES:

sage: TableauTuple([[[7,8,9]],[],[[1,2,3],[4,5],[6]]]).size()
9
symmetric_group_action_on_entries(w)

Return the action of a permutation w on self.

Consider a standard tableau tuple \(T = (t^{(1)}, t^{(2)}, \ldots t^{(l)})\) 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 \((k, i, j)\) is \(a\), then the entry becomes \(w(a)\). In general, the resulting tableau tuple \(wT\) may not be standard.

INPUT:

  • w – a permutation

EXAMPLES:

sage: TableauTuple([[[1,2],[4]],[[3,5]]]).symmetric_group_action_on_entries( Permutation(((4,5))) )
([[1, 2], [5]], [[3, 4]])
sage: TableauTuple([[[1,2],[4]],[[3,5]]]).symmetric_group_action_on_entries( Permutation(((1,2))) )
([[2, 1], [4]], [[3, 5]])
to_list()

Return the list representation of the tableaux tuple self.

EXAMPLES:

sage: TableauTuple([ [[1,2,3],[4,5]], [[6,7],[8,9]] ]).to_list()
[[[1, 2, 3], [4, 5]], [[6, 7], [8, 9]]]
to_permutation()

Returns a permutation with the entries in the tableau tuple self which is obtained by self obtained by reading the entries of the tableau tuple in order from left to right along the rows, and then top to bottom, in each component and then left to right along the components.

EXAMPLES:

sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_permutation()
[12, 11, 9, 10, 8, 5, 6, 7, 3, 4, 1, 2]
to_word()

Returns a word obtained from a row reading of the tableau tuple self.

EXAMPLES:

sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_word_by_row()
word: 12,11,9,10,8,5,6,7,3,4,1,2
to_word_by_column()

Returns the word obtained from a column reading of the tableau tuple self.

EXAMPLES:

sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_word_by_column()
word: 12,11,9,10,8,5,6,7,3,1,4,2
to_word_by_row()

Returns a word obtained from a row reading of the tableau tuple self.

EXAMPLES:

sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_word_by_row()
word: 12,11,9,10,8,5,6,7,3,4,1,2
up(n=None)

An iterator for all the TableauTuple that can be obtained from self by adding a cell with the label n. If n is not specified then a cell with label n will be added to the tableau tuple, where n-1 is the size of the tableau tuple before any cells are added.

EXAMPLES:

sage: list(TableauTuple([[[1,2]],[[3]]]).up())
[([[1, 2, 4]], [[3]]),
  ([[1, 2], [4]], [[3]]),
  ([[1, 2]], [[3, 4]]),
  ([[1, 2]], [[3], [4]])]
class sage.combinat.tableau_tuple.TableauTuples

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

A factory class for the various classes of tableau tuples.

INPUT:

There are three optional arguments:

  • shape – determines a PartitionTuple which gives the shape of the TableauTuples
  • level – the level of the tableau tuples (positive integer)
  • size – the size of the tableau tuples (non-negative integer)

It is not necessary to use the keywords. If they are not specified then the first integer argument specifies the level and the second the size of the tableaux.

OUTPUT:

  • The corresponding class of tableau tuples.

The entries of a tableau can be any sage object. Because of this, no enumeration of the set of TableauTuples is possible.

EXAMPLES:

sage: T3 = TableauTuples(3); T3
Tableau tuples of level 3
sage: [['a','b']] in TableauTuples()
True
sage: [['a','b']] in TableauTuples(level=3)
False
sage: t = TableauTuples(level=3)([[],[[1,1,1]],[]]); t
([], [[1, 1, 1]], [])
sage: t in T3
True
sage: t in TableauTuples()
True
sage: t in TableauTuples(size=3)
True
sage: t in TableauTuples(size=4)
False
sage: t in StandardTableauTuples()
False
sage: t.parent()
Tableau tuples of level 3
sage: t.category()
Category of elements of Tableau tuples of level 3

TESTS:

sage: TableauTuples(0)
Traceback (most recent call last):
...
ValueError: the level must be a positive integer

sage: t = TableauTuples(3)([[],[],[[1,2],[3]]])
sage: t.parent()
Tableau tuples of level 3
sage: TableauTuples(t)
Traceback (most recent call last):
...
ValueError: the level must be a positive integer
sage: TableauTuples(3)([[1, 1]])
Traceback (most recent call last):
...
ValueError: [[1, 1]] is not an element of Tableau tuples of level 3

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

sage: [[1]] in TableauTuples()
True
sage: [] in TableauTuples()
True

sage: TableauTuples(level=0)
Traceback (most recent call last):
...
ValueError: the level must be a positive integer

sage: TestSuite( TableauTuples() ).run()
sage: TestSuite( TableauTuples(level=1) ).run()
sage: TestSuite( TableauTuples(level=2) ).run()
sage: TestSuite( TableauTuples(level=6) ).run()
sage: TestSuite( TableauTuples(size=0) ).run()
sage: TestSuite( TableauTuples(size=1) ).run()
sage: TestSuite( TableauTuples(size=2) ).run()
sage: TestSuite( TableauTuples(size=10) ).run()
sage: TestSuite( TableauTuples(level=1, size=0) ).run()
sage: TestSuite( TableauTuples(level=1, size=1) ).run()
sage: TestSuite( TableauTuples(level=1, size=10) ).run()
sage: TestSuite( TableauTuples(level=2, size=0) ).run()
sage: TestSuite( TableauTuples(level=2, size=1) ).run()
sage: TestSuite( TableauTuples(level=2, size=10) ).run()
sage: TestSuite( TableauTuples(level=6, size=0) ).run()
sage: TestSuite( TableauTuples(level=6, size=1) ).run()
sage: TestSuite( TableauTuples(level=6, size=10) ).run()

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

sage: 1 in TableauTuples()
False
Element

alias of TableauTuple

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.

level()

Return the level of a tableau tuple in self, or None if different tableau tuples in self can have different sizes. The level of a tableau tuple is just the level of the underlying PartitionTuple.

EXAMPLES:

sage: TableauTuples().level() is None
True
sage: TableauTuples(7).level()
7
level_one_parent_class

alias of Tableaux_all

list()

If the set of tableau tuples self is finite then this function returns the list of these tableau tuples. If the class is infinite an error is returned.

EXAMPLES:

sage: StandardTableauTuples([[2,1],[2]]).list()
[([[1, 2], [3]], [[4, 5]]),
 ([[1, 3], [2]], [[4, 5]]),
 ([[1, 2], [4]], [[3, 5]]),
 ([[1, 3], [4]], [[2, 5]]),
 ([[2, 3], [4]], [[1, 5]]),
 ([[1, 4], [2]], [[3, 5]]),
 ([[1, 4], [3]], [[2, 5]]),
 ([[2, 4], [3]], [[1, 5]]),
 ([[1, 2], [5]], [[3, 4]]),
 ([[1, 3], [5]], [[2, 4]]),
 ([[2, 3], [5]], [[1, 4]]),
 ([[1, 4], [5]], [[2, 3]]),
 ([[2, 4], [5]], [[1, 3]]),
 ([[3, 4], [5]], [[1, 2]]),
 ([[1, 5], [2]], [[3, 4]]),
 ([[1, 5], [3]], [[2, 4]]),
 ([[2, 5], [3]], [[1, 4]]),
 ([[1, 5], [4]], [[2, 3]]),
 ([[2, 5], [4]], [[1, 3]]),
 ([[3, 5], [4]], [[1, 2]])]
size()

Return the size of a tableau tuple in self, or None if different tableau tuples in self can have sifferent sizes. The size of a tableau tuple is just the size of the underlying PartitionTuple.

EXAMPLES:

sage: TableauTuples(size=14).size()
14
class sage.combinat.tableau_tuple.TableauTuples_all

Bases: sage.combinat.tableau_tuple.TableauTuples

The parent class of all TableauTuples, with arbitrary level and size.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: TableauTuples().an_element()
([[1]], [[2]], [[3]], [[4]], [[5]], [[6]], [[7]])
class sage.combinat.tableau_tuple.TableauTuples_level(level)

Bases: sage.combinat.tableau_tuple.TableauTuples

Class of all TableauTuples with a fixed level and arbitrary size.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: TableauTuples(3).an_element()
([], [], [])
sage: TableauTuples(5).an_element()
([], [], [], [], [])
sage: T = TableauTuples(0)
Traceback (most recent call last):
...
ValueError: the level must be a positive integer
class sage.combinat.tableau_tuple.TableauTuples_level_size(level, size)

Bases: sage.combinat.tableau_tuple.TableauTuples

Class of all TableauTuples with a fixed level and a fixed size.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: TableauTuples(3,0).an_element()
([], [], [])
sage: TableauTuples(3,1).an_element()
([[1]], [], [])
sage: TableauTuples(3,2).an_element()
([[1, 2]], [], [])
class sage.combinat.tableau_tuple.TableauTuples_size(size)

Bases: sage.combinat.tableau_tuple.TableauTuples

Class of all TableauTuples with a arbitrary level and fixed size.

an_element()

Returns a particular element of the class.

EXAMPLES:

sage: TableauTuples(size=3).an_element()
([], [[1, 2, 3]], [])
sage: TableauTuples(size=0).an_element()
([], [], [])

Previous topic

Ribbon Tableaux

Next topic

Strong and weak tableaux

This Page