TableauTuples - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# 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 tuples 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 tableau 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

    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

Python

    >>> from sage.all import *
    >>> TableauTuple([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]])
    [[1, 2, 3], [4, 5]]
    >>> t = TableauTuple([ [[Integer(6),Integer(7)],[Integer(8),Integer(9)]],[[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]] ]); t
    ([[6, 7], [8, 9]], [[1, 2, 3], [4, 5]])
    >>> t.pp()
      6  7     1  2  3
      8  9     4  5
    >>> t(Integer(0),Integer(0),Integer(1))
    7
    >>> t(Integer(1),Integer(0),Integer(1))
    2
    >>> t.shape()
    ([2, 2], [3, 2])
    >>> t.size()
    9
    >>> t.level()
    2
    >>> t.components()
    [[[6, 7], [8, 9]], [[1, 2, 3], [4, 5]]]
    >>> t.entries()
    [6, 7, 8, 9, 1, 2, 3, 4, 5]
    >>> t.parent()
    Tableau tuples
    >>> 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

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

[Python]

    >>> from sage.all import *
    >>> s = StandardTableauTuple([ [[Integer(1),Integer(2)],[Integer(3)]],[[Integer(4),Integer(5)]]])
    >>> s.category()
    Category of elements of Standard tableau tuples
    >>> t = TableauTuple([ [[Integer(1),Integer(2)],[Integer(3)]],[[Integer(4),Integer(5)]]])
    >>> t.is_standard(), t.is_column_strict(), t.is_row_strict()
    (True, True, True)
    >>> t.category()
    Category of elements of Tableau tuples
    >>> s == t
    True
    >>> s is t
    False
    >>> s == StandardTableauTuple(t)
    True
    >>> StandardTableauTuples([ [Integer(2),Integer(1)],[Integer(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

    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

Python

    >>> from sage.all import *
    >>> TableauTuples( level=Integer(1) ) is Tableaux()
    True
    >>> TableauTuple([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]])
    [[1, 2, 3], [4, 5]]
    >>> TableauTuple([ [[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]] ])
    [[1, 2, 3], [4, 5]]
    >>> TableauTuple([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]]) == Tableau([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(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

    sage: StandardTableauTuples()[:10]                                                  # needs sage.libs.flint
    [(),
     ([[1]]),
     ([], []),
     ([[1, 2]]),
     ([[1], [2]]),
     ([[1]], []),
     ([], [[1]]),
     ([], [], []),
     ([[1, 2, 3]]),
     ([[1, 3], [2]])]

[Python]

    >>> from sage.all import *
    >>> StandardTableauTuples()[:Integer(10)]                                                  # needs sage.libs.flint
    [(),
     ([[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).

- Andrew Mathas (2016-08-11): Row standard tableaux added

Element classes:

- `TableauTuples`

- `StandardTableauTuples`

- `RowStandardTableauTuples`

Factory classes:

- `TableauTuples`

- `StandardTableauTuples`

- `RowStandardTableauTuples`

Parent classes:

- `TableauTuples_all`

- `TableauTuples_level`

- `TableauTuples_size`

- `TableauTuples_level_size`

- `StandardTableauTuples_all`

- `StandardTableauTuples_level`

- `StandardTableauTuples_size`

- `StandardTableauTuples_level_size`

- `StandardTableauTuples_shape`

- `StandardTableaux_residue`

- `StandardTableaux_residue_shape`

- `RowStandardTableauTuples_all`

- `RowStandardTableauTuples_level`

- `RowStandardTableauTuples_size`

- `RowStandardTableauTuples_level_size`

- `RowStandardTableauTuples_shape`

- `RowStandardTableauTuples_residue`

- `RowStandardTableauTuples_residue_shape`

See also

- `Tableau`

- `StandardTableau`

- `Tableaux`

- `StandardTableaux`

- `Partitions`

- `PartitionTuples`

- `ResidueSequence`

Todo

Implement semistandard tableau tuples as defined in [DJM1998].

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

class sage.combinat.tableau_tuple.RowStandardTableauTuple(parent, t, check=True)

  Bases: `TableauTuple`

  A class for row standard tableau tuples of shape a partition tuple.

  A row standard tableau tuple of size \(n\) is an ordered tuple of row standard tableaux (see `RowStandardTableau`), with entries \(1, 2, \ldots, n\) such that, in each component, the entries are in increasing order along each row. If the tableau in component \(k\) has shape \(\lambda^{(k)}\) then \(\lambda=(\lambda^{(1)},\ldots,\lambda^{(l)}\) is a `PartitionTuple`.

  Note

  The tableaux appearing in a `RowStandardTableauTuple` are row strict, but individually they are not standard tableaux because the entries in any single component of a `RowStandardTableauTuple` 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: a `RowStandardTableauTuple` object constructed from `t`

  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 coordinates `[k,r,c]` in a `TableauTuple` refer to the component, row and column indices, respectively.

  EXAMPLES:

  Sage

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

  Python

      >>> from sage.all import *
      >>> t = RowStandardTableauTuple([[[Integer(4),Integer(7)],[Integer(3)]],[[Integer(2),Integer(6),Integer(8)],[Integer(1),Integer(5)]],[[Integer(9)]]]); t
      ([[4, 7], [3]], [[2, 6, 8], [1, 5]], [[9]])
      >>> t.pp()
        4  7     2  6  8     9
        3        1  5
      >>> t.shape()
      ([2, 1], [3, 2], [1])
      >>> t[Integer(0)].pp()  # pretty printing
        4  7
        3
      >>> t.is_row_strict()
      True
      >>> t[Integer(0)].is_standard()
      False
      >>> RowStandardTableauTuple([[],[],[]]) # An empty tableau tuple
      ([], [], [])
      >>> RowStandardTableauTuple([[[Integer(4),Integer(5)],[Integer(6)]],[[Integer(1),Integer(2),Integer(3)]]]) in StandardTableauTuples()
      True
      >>> RowStandardTableauTuple([[[Integer(5),Integer(6)],[Integer(4)]],[[Integer(1),Integer(2),Integer(3)]]]) in StandardTableauTuples()
      False

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

  Sage

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

  [Python]

      >>> from sage.all import *
      >>> RST = RowStandardTableauTuples()
      >>> RST([[[Integer(4),Integer(5)],[Integer(7)]],[[Integer(1),Integer(2),Integer(3)],[Integer(6),Integer(8)]],[[Integer(9)]]])
      ([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])

  See also

  - `RowTableau`

  - `RowTableaux`

  - `TableauTuples`

  - `TableauTuple`

  - `StandardTableauTuples`

  - `StandardTableauTuple`

  - `RowStandardTableauTuples`

  codegree(e, multicharge)

    Return the Brundan-Kleshchev-Wang [BKW2011] codegree of `self`.

    The codegree of a tableau is an integer that is defined recursively by successively stripping off the number \(k\), for \(k = n, n-1, \ldots, 1\) and at stage adding the number of addable cell of the same residue minus the number of removable cells of the same residue as \(k\) and which are above \(k\) in the diagram.

    The codegree of the tableau `self` gives the degree of “dual” homogeneous basis element of the graded Specht module which is indexed by `self`.

    INPUT:

    - `e` – the quantum characteristic

    - `multicharge` – the multicharge

    OUTPUT: the codegree of the tableau `self`, which is an integer

    EXAMPLES:

    Sage

        sage: StandardTableauTuple([[[1]], [], []]).codegree(0,(0,0,0))
        0
        sage: StandardTableauTuple([[],[[1]], []]).codegree(0,(0,0,0))
        1
        sage: StandardTableauTuple([[], [], [[1]]]).codegree(0,(0,0,0))
        2
        sage: StandardTableauTuple([[[1]],[[2]], []]).codegree(0,(0,0,0))
        -1
        sage: StandardTableauTuple([[[1]], [], [[2]]]).codegree(0,(0,0,0))
        0
        sage: StandardTableauTuple([[],[[1]], [[2]]]).codegree(0,(0,0,0))
        1
        sage: StandardTableauTuple([[[2]],[[1]], []]).codegree(0,(0,0,0))
        1
        sage: StandardTableauTuple([[[2]], [], [[1]]]).codegree(0,(0,0,0))
        2
        sage: StandardTableauTuple([[],[[2]], [[1]]]).codegree(0,(0,0,0))
        3

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(1)]], [], []]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        0
        >>> StandardTableauTuple([[],[[Integer(1)]], []]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        1
        >>> StandardTableauTuple([[], [], [[Integer(1)]]]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        2
        >>> StandardTableauTuple([[[Integer(1)]],[[Integer(2)]], []]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        -1
        >>> StandardTableauTuple([[[Integer(1)]], [], [[Integer(2)]]]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        0
        >>> StandardTableauTuple([[],[[Integer(1)]], [[Integer(2)]]]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        1
        >>> StandardTableauTuple([[[Integer(2)]],[[Integer(1)]], []]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        1
        >>> StandardTableauTuple([[[Integer(2)]], [], [[Integer(1)]]]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        2
        >>> StandardTableauTuple([[],[[Integer(2)]], [[Integer(1)]]]).codegree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        3

  degree(e, multicharge)

    Return the Brundan-Kleshchev-Wang [BKW2011] degree of `self`.

    The degree of a tableau is an integer that is defined recursively by successively stripping off the number \(k\), for \(k = n, n-1, \ldots, 1\), and at stage adding the count of the number of addable cell of the same residue minus the number of removable cells of them same residue as \(k\) and that are below \(k\) in the diagram.

    Note that even though this degree function was defined by Brundan-Kleshchev-Wang [BKW2011] the underlying combinatorics is much older, going back at least to Misra and Miwa.

    The degrees of the tableau \(T\) gives the degree of the homogeneous basis element of the graded Specht module which is indexed by \(T\).

    INPUT:

    - `e` – the quantum characteristic `e`

    - `multicharge` – (default: `[0]`) the multicharge

    OUTPUT: the degree of the tableau `self`, which is an integer

    EXAMPLES:

    Sage

        sage: StandardTableauTuple([[[1]], [], []]).degree(0,(0,0,0))
        2
        sage: StandardTableauTuple([[],[[1]], []]).degree(0,(0,0,0))
        1
        sage: StandardTableauTuple([[], [], [[1]]]).degree(0,(0,0,0))
        0
        sage: StandardTableauTuple([[[1]],[[2]], []]).degree(0,(0,0,0))
        3
        sage: StandardTableauTuple([[[1]], [], [[2]]]).degree(0,(0,0,0))
        2
        sage: StandardTableauTuple([[],[[1]], [[2]]]).degree(0,(0,0,0))
        1
        sage: StandardTableauTuple([[[2]],[[1]], []]).degree(0,(0,0,0))
        1
        sage: StandardTableauTuple([[[2]], [], [[1]]]).degree(0,(0,0,0))
        0
        sage: StandardTableauTuple([[],[[2]], [[1]]]).degree(0,(0,0,0))
        -1

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(1)]], [], []]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        2
        >>> StandardTableauTuple([[],[[Integer(1)]], []]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        1
        >>> StandardTableauTuple([[], [], [[Integer(1)]]]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        0
        >>> StandardTableauTuple([[[Integer(1)]],[[Integer(2)]], []]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        3
        >>> StandardTableauTuple([[[Integer(1)]], [], [[Integer(2)]]]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        2
        >>> StandardTableauTuple([[],[[Integer(1)]], [[Integer(2)]]]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        1
        >>> StandardTableauTuple([[[Integer(2)]],[[Integer(1)]], []]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        1
        >>> StandardTableauTuple([[[Integer(2)]], [], [[Integer(1)]]]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        0
        >>> StandardTableauTuple([[],[[Integer(2)]], [[Integer(1)]]]).degree(Integer(0),(Integer(0),Integer(0),Integer(0)))
        -1

  inverse(k)

    Return the cell containing `k` in the tableau tuple `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableauTuple([[[3,4],[1,2]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(1)
        (0, 1, 0)
        sage: RowStandardTableauTuple([[[3,4],[1,2]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(2)
        (0, 1, 1)
        sage: RowStandardTableauTuple([[[3,4],[1,2]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(3)
        (0, 0, 0)
        sage: RowStandardTableauTuple([[[3,4],[1,2]],[[5,6,7],[8]],[[9,10],[11],[12]]]).inverse(4)
        (0, 0, 1)
        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)

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuple([[[Integer(3),Integer(4)],[Integer(1),Integer(2)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(1))
        (0, 1, 0)
        >>> RowStandardTableauTuple([[[Integer(3),Integer(4)],[Integer(1),Integer(2)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(2))
        (0, 1, 1)
        >>> RowStandardTableauTuple([[[Integer(3),Integer(4)],[Integer(1),Integer(2)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(3))
        (0, 0, 0)
        >>> RowStandardTableauTuple([[[Integer(3),Integer(4)],[Integer(1),Integer(2)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(4))
        (0, 0, 1)
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(1))
        (0, 0, 0)
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(2))
        (0, 0, 1)
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(3))
        (0, 1, 0)
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).inverse(Integer(12))
        (2, 2, 0)

  residue_sequence(e, multicharge)

    Return the `sage.combinat.tableau_residues.ResidueSequence` of `self`.

    INPUT:

    - `e` – integer in \(\{0, 2, 3, 4, 5, \ldots\}\)

    - `multicharge` – a sequence of integers of length equal to the level/length of `self`

    OUTPUT:

    The `residue sequence` of the tableau.

    EXAMPLES:

    Sage

        sage: RowStandardTableauTuple([[[5]],[[3,4],[1,2]]]).residue_sequence(3,[0,0])
        3-residue sequence (2,0,0,1,0) with multicharge (0,0)
        sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).residue_sequence(3,[0,1])
        3-residue sequence (1,2,0,1,0) with multicharge (0,1)
        sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).residue_sequence(3,[0,2])
        3-residue sequence (2,0,1,2,0) with multicharge (0,2)

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuple([[[Integer(5)]],[[Integer(3),Integer(4)],[Integer(1),Integer(2)]]]).residue_sequence(Integer(3),[Integer(0),Integer(0)])
        3-residue sequence (2,0,0,1,0) with multicharge (0,0)
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue_sequence(Integer(3),[Integer(0),Integer(1)])
        3-residue sequence (1,2,0,1,0) with multicharge (0,1)
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue_sequence(Integer(3),[Integer(0),Integer(2)])
        3-residue sequence (2,0,1,2,0) with multicharge (0,2)

class sage.combinat.tableau_tuple.RowStandardTableauTuples

  Bases: `TableauTuples`

  A factory class for the various classes of tuples of row 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` – list or a partition tuple specifying the `shape()` of the row standard tableau tuples

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

  OUTPUT: the appropriate subclass of `RowStandardTableauTuples`

  A tuple of row standard tableau is a tableau whose entries are positive integers which increase from left to right along the rows 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

      sage: tabs = RowStandardTableauTuples([[2],[1,1]]); tabs
      Row standard tableau tuples of shape ([2], [1, 1])
      sage: tabs.cardinality()
      12
      sage: tabs[:]                                                                   # needs sage.graphs sage.rings.finite_rings
      [([[3, 4]], [[2], [1]]),
       ([[2, 4]], [[3], [1]]),
       ([[1, 4]], [[3], [2]]),
       ([[1, 2]], [[4], [3]]),
       ([[1, 3]], [[4], [2]]),
       ([[2, 3]], [[4], [1]]),
       ([[1, 4]], [[2], [3]]),
       ([[1, 3]], [[2], [4]]),
       ([[1, 2]], [[3], [4]]),
       ([[2, 3]], [[1], [4]]),
       ([[2, 4]], [[1], [3]]),
       ([[3, 4]], [[1], [2]])]

      sage: tabs = RowStandardTableauTuples(level=3); tabs
      Row standard tableau tuples of level 3
      sage: tabs[100]                                                                 # needs sage.libs.flint
      ([], [], [[2, 3], [1]])

      sage: RowStandardTableauTuples()[0]                                             # needs sage.libs.flint
      ([])

  Python

      >>> from sage.all import *
      >>> tabs = RowStandardTableauTuples([[Integer(2)],[Integer(1),Integer(1)]]); tabs
      Row standard tableau tuples of shape ([2], [1, 1])
      >>> tabs.cardinality()
      12
      >>> tabs[:]                                                                   # needs sage.graphs sage.rings.finite_rings
      [([[3, 4]], [[2], [1]]),
       ([[2, 4]], [[3], [1]]),
       ([[1, 4]], [[3], [2]]),
       ([[1, 2]], [[4], [3]]),
       ([[1, 3]], [[4], [2]]),
       ([[2, 3]], [[4], [1]]),
       ([[1, 4]], [[2], [3]]),
       ([[1, 3]], [[2], [4]]),
       ([[1, 2]], [[3], [4]]),
       ([[2, 3]], [[1], [4]]),
       ([[2, 4]], [[1], [3]]),
       ([[3, 4]], [[1], [2]])]

      >>> tabs = RowStandardTableauTuples(level=Integer(3)); tabs
      Row standard tableau tuples of level 3
      >>> tabs[Integer(100)]                                                                 # needs sage.libs.flint
      ([], [], [[2, 3], [1]])

      >>> RowStandardTableauTuples()[Integer(0)]                                             # needs sage.libs.flint
      ([])

  See also

  - `TableauTuples`

  - `Tableau`

  - `RowStandardTableau`

  - `RowStandardTableauTuples`

  Element

    alias of `RowStandardTableauTuple`

  level_one_parent_class

    alias of `RowStandardTableaux_all`

  shape()

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

    EXAMPLES:

    Sage

        sage: tabs=RowStandardTableauTuples(shape=[[5,2],[3,2],[],[1,1,1],[3]]); tabs
        Row 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: RowStandardTableauTuples().shape() is None
        True

    Python

        >>> from sage.all import *
        >>> tabs=RowStandardTableauTuples(shape=[[Integer(5),Integer(2)],[Integer(3),Integer(2)],[],[Integer(1),Integer(1),Integer(1)],[Integer(3)]]); tabs
        Row standard tableau tuples of shape ([5, 2], [3, 2], [], [1, 1, 1], [3])
        >>> tabs.shape()
        ([5, 2], [3, 2], [], [1, 1, 1], [3])
        >>> RowStandardTableauTuples().shape() is None
        True

class sage.combinat.tableau_tuple.RowStandardTableauTuples_all

  Bases: `RowStandardTableauTuples`, `DisjointUnionEnumeratedSets`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuples().an_element()
        ([[4, 5, 6, 7]], [[2, 3]], [[1]])

class sage.combinat.tableau_tuple.RowStandardTableauTuples_level(level)

  Bases: `RowStandardTableauTuples`, `DisjointUnionEnumeratedSets`

  Class of all `RowStandardTableauTuples` with a fixed `level` and arbitrary `size`.

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuples(Integer(2)).an_element()
        ([[1]], [[2, 3]])
        >>> RowStandardTableauTuples(Integer(3)).an_element()
        ([[1]], [[2, 3]], [[4, 5, 6, 7]])

class sage.combinat.tableau_tuple.RowStandardTableauTuples_level_size(level, size)

  Bases: `RowStandardTableauTuples`, `DisjointUnionEnumeratedSets`

  Class of all `RowStandardTableauTuples` with a fixed `level` and a fixed `size`.

  an_element()

    Return a particular element of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableauTuples(5, size=2).an_element()                      # needs sage.libs.flint
        ([], [], [], [], [[1], [2]])
        sage: RowStandardTableauTuples(2, size=4).an_element()                      # needs sage.libs.flint
        ([[1]], [[2, 3], [4]])

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuples(Integer(5), size=Integer(2)).an_element()                      # needs sage.libs.flint
        ([], [], [], [], [[1], [2]])
        >>> RowStandardTableauTuples(Integer(2), size=Integer(4)).an_element()                      # needs sage.libs.flint
        ([[1]], [[2, 3], [4]])

class sage.combinat.tableau_tuple.RowStandardTableauTuples_residue(residue)

  Bases: `RowStandardTableauTuples`

  Class of all row standard tableau tuples with a fixed residue sequence.

  Implicitly, this also specifies the quantum characteristic, multicharge and hence the level and size of the tableaux.

  Note

  This class is not intended to be called directly, but rather, it is accessed through the row standard tableaux.

  EXAMPLES:

  Sage

      sage: RowStandardTableau([[3,4,5],[1,2]]).residue_sequence(2).row_standard_tableaux()
      Row standard tableaux with 2-residue sequence (1,0,0,1,0) and multicharge (0)
      sage: RowStandardTableau([[3,4,5],[1,2]]).residue_sequence(3).row_standard_tableaux()
      Row standard tableaux with 3-residue sequence (2,0,0,1,2) and multicharge (0)
      sage: RowStandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(2,(0,0)).row_standard_tableaux()
      Row standard tableaux with 2-residue sequence (0,1,0,1,0,1,1) and multicharge (0,0)
      sage: RowStandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(3,(0,1)).row_standard_tableaux()
      Row standard tableaux with 3-residue sequence (1,2,0,0,0,1,2) and multicharge (0,1)

  Python

      >>> from sage.all import *
      >>> RowStandardTableau([[Integer(3),Integer(4),Integer(5)],[Integer(1),Integer(2)]]).residue_sequence(Integer(2)).row_standard_tableaux()
      Row standard tableaux with 2-residue sequence (1,0,0,1,0) and multicharge (0)
      >>> RowStandardTableau([[Integer(3),Integer(4),Integer(5)],[Integer(1),Integer(2)]]).residue_sequence(Integer(3)).row_standard_tableaux()
      Row standard tableaux with 3-residue sequence (2,0,0,1,2) and multicharge (0)
      >>> RowStandardTableauTuple([[[Integer(5),Integer(6)],[Integer(7)]],[[Integer(1),Integer(2),Integer(3)],[Integer(4)]]]).residue_sequence(Integer(2),(Integer(0),Integer(0))).row_standard_tableaux()
      Row standard tableaux with 2-residue sequence (0,1,0,1,0,1,1) and multicharge (0,0)
      >>> RowStandardTableauTuple([[[Integer(5),Integer(6)],[Integer(7)]],[[Integer(1),Integer(2),Integer(3)],[Integer(4)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux()
      Row standard tableaux with 3-residue sequence (1,2,0,0,0,1,2) and multicharge (0,1)

  an_element()

    Return a particular element of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableau([[2,3],[1]]).residue_sequence(3).row_standard_tableaux().an_element()
        [[2, 3], [1]]
        sage: StandardTableau([[1,3],[2]]).residue_sequence(3).row_standard_tableaux().an_element()
        [[1, 3], [2]]
        sage: RowStandardTableauTuple([[[4]],[[2,3],[1]]]).residue_sequence(3,(0,1)).row_standard_tableaux().an_element()                                   # needs sage.libs.flint
        sage: StandardTableauTuple([[[4]],[[1,3],[2]]]).residue_sequence(3,(0,1)).row_standard_tableaux().an_element()                                      # needs sage.libs.flint
        ([[4], [3], [1], [2]], [])

    Python

        >>> from sage.all import *
        >>> RowStandardTableau([[Integer(2),Integer(3)],[Integer(1)]]).residue_sequence(Integer(3)).row_standard_tableaux().an_element()
        [[2, 3], [1]]
        >>> StandardTableau([[Integer(1),Integer(3)],[Integer(2)]]).residue_sequence(Integer(3)).row_standard_tableaux().an_element()
        [[1, 3], [2]]
        >>> RowStandardTableauTuple([[[Integer(4)]],[[Integer(2),Integer(3)],[Integer(1)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().an_element()                                   # needs sage.libs.flint
        >>> StandardTableauTuple([[[Integer(4)]],[[Integer(1),Integer(3)],[Integer(2)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().an_element()                                      # needs sage.libs.flint
        ([[4], [3], [1], [2]], [])

  level()

    Return the level of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableau([[2,3],[1]]).residue_sequence(3,(0,1)).row_standard_tableaux().level()
        2
        sage: StandardTableau([[1,2],[3]]).residue_sequence(3,(0,1)).row_standard_tableaux().level()
        2
        sage: RowStandardTableauTuple([[[4]],[[2,3],[1]]]).residue_sequence(3,(0,1)).row_standard_tableaux().level()
        2
        sage: StandardTableauTuple([[[4]],[[1,3],[2]]]).residue_sequence(3,(0,1)).row_standard_tableaux().level()
        2

    Python

        >>> from sage.all import *
        >>> RowStandardTableau([[Integer(2),Integer(3)],[Integer(1)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().level()
        2
        >>> StandardTableau([[Integer(1),Integer(2)],[Integer(3)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().level()
        2
        >>> RowStandardTableauTuple([[[Integer(4)]],[[Integer(2),Integer(3)],[Integer(1)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().level()
        2
        >>> StandardTableauTuple([[[Integer(4)]],[[Integer(1),Integer(3)],[Integer(2)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().level()
        2

  multicharge()

    Return the multicharge of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableau([[2,3],[1]]).residue_sequence(3,(0,1)).row_standard_tableaux().multicharge()
        (0, 1)
        sage: StandardTableau([[1,2],[3]]).residue_sequence(3,(0,1)).row_standard_tableaux().multicharge()
        (0, 1)
        sage: RowStandardTableauTuple([[[4]],[[2,3],[1]]]).residue_sequence(3,(0,1)).row_standard_tableaux().multicharge()
        (0, 1)
        sage: StandardTableauTuple([[[4]],[[1,3],[2]]]).residue_sequence(3,(0,1)).row_standard_tableaux().multicharge()
        (0, 1)

    Python

        >>> from sage.all import *
        >>> RowStandardTableau([[Integer(2),Integer(3)],[Integer(1)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().multicharge()
        (0, 1)
        >>> StandardTableau([[Integer(1),Integer(2)],[Integer(3)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().multicharge()
        (0, 1)
        >>> RowStandardTableauTuple([[[Integer(4)]],[[Integer(2),Integer(3)],[Integer(1)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().multicharge()
        (0, 1)
        >>> StandardTableauTuple([[[Integer(4)]],[[Integer(1),Integer(3)],[Integer(2)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().multicharge()
        (0, 1)

  quantum_characteristic()

    Return the quantum characteristic of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableau([[2,3],[1]]).residue_sequence(3,(0,1)).row_standard_tableaux().quantum_characteristic()
        3
        sage: StandardTableau([[1,2],[3]]).residue_sequence(3,(0,1)).row_standard_tableaux().quantum_characteristic()
        3
        sage: RowStandardTableauTuple([[[4]],[[2,3],[1]]]).residue_sequence(3,(0,1)).row_standard_tableaux().quantum_characteristic()
        3
        sage: StandardTableauTuple([[[4]],[[1,3],[2]]]).residue_sequence(3,(0,1)).row_standard_tableaux().quantum_characteristic()
        3

    Python

        >>> from sage.all import *
        >>> RowStandardTableau([[Integer(2),Integer(3)],[Integer(1)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().quantum_characteristic()
        3
        >>> StandardTableau([[Integer(1),Integer(2)],[Integer(3)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().quantum_characteristic()
        3
        >>> RowStandardTableauTuple([[[Integer(4)]],[[Integer(2),Integer(3)],[Integer(1)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().quantum_characteristic()
        3
        >>> StandardTableauTuple([[[Integer(4)]],[[Integer(1),Integer(3)],[Integer(2)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().quantum_characteristic()
        3

  residue_sequence()

    Return the residue sequence of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableau([[2,3],[1]]).residue_sequence(3,(0,1)).row_standard_tableaux().residue_sequence()
        3-residue sequence (2,0,1) with multicharge (0,1)
        sage: StandardTableau([[1,2],[3]]).residue_sequence(3,(0,1)).row_standard_tableaux().residue_sequence()
        3-residue sequence (0,1,2) with multicharge (0,1)
        sage: RowStandardTableauTuple([[[4]],[[2,3],[1]]]).residue_sequence(3,(0,1)).row_standard_tableaux().residue_sequence()
        3-residue sequence (0,1,2,0) with multicharge (0,1)
        sage: StandardTableauTuple([[[4]],[[1,3],[2]]]).residue_sequence(3,(0,1)).row_standard_tableaux().residue_sequence()
        3-residue sequence (1,0,2,0) with multicharge (0,1)

    Python

        >>> from sage.all import *
        >>> RowStandardTableau([[Integer(2),Integer(3)],[Integer(1)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().residue_sequence()
        3-residue sequence (2,0,1) with multicharge (0,1)
        >>> StandardTableau([[Integer(1),Integer(2)],[Integer(3)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().residue_sequence()
        3-residue sequence (0,1,2) with multicharge (0,1)
        >>> RowStandardTableauTuple([[[Integer(4)]],[[Integer(2),Integer(3)],[Integer(1)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().residue_sequence()
        3-residue sequence (0,1,2,0) with multicharge (0,1)
        >>> StandardTableauTuple([[[Integer(4)]],[[Integer(1),Integer(3)],[Integer(2)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().residue_sequence()
        3-residue sequence (1,0,2,0) with multicharge (0,1)

  size()

    Return the size of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableau([[2,3],[1]]).residue_sequence(3,(0,1)).row_standard_tableaux().size()
        3
        sage: StandardTableau([[1,2],[3]]).residue_sequence(3,(0,1)).row_standard_tableaux().size()
        3
        sage: RowStandardTableauTuple([[[4]],[[2,3],[1]]]).residue_sequence(3,(0,1)).row_standard_tableaux().size()
        4
        sage: StandardTableauTuple([[[4]],[[1,3],[2]]]).residue_sequence(3,(0,1)).row_standard_tableaux().size()
        4

    Python

        >>> from sage.all import *
        >>> RowStandardTableau([[Integer(2),Integer(3)],[Integer(1)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().size()
        3
        >>> StandardTableau([[Integer(1),Integer(2)],[Integer(3)]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().size()
        3
        >>> RowStandardTableauTuple([[[Integer(4)]],[[Integer(2),Integer(3)],[Integer(1)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().size()
        4
        >>> StandardTableauTuple([[[Integer(4)]],[[Integer(1),Integer(3)],[Integer(2)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).row_standard_tableaux().size()
        4

class sage.combinat.tableau_tuple.RowStandardTableauTuples_residue_shape(residue, shape)

  Bases: `RowStandardTableauTuples_residue`

  All row standard tableau tuples with a fixed residue and shape.

  INPUT:

  - `shape` – the shape of the partitions or partition tuples

  - `residue` – the residue sequence of the label

  EXAMPLES:

  Sage

      sage: res = RowStandardTableauTuple([[[3,6],[1]],[[5,7],[4],[2]]]).residue_sequence(3,(0,0))
      sage: tabs = res.row_standard_tableaux([[2,1],[2,1,1]]); tabs
      Row standard (2,1|2,1^2)-tableaux with 3-residue sequence (2,1,0,2,0,1,1) and multicharge (0,0)
      sage: tabs.shape()
      ([2, 1], [2, 1, 1])
      sage: tabs.level()
      2
      sage: tabs[:6]
      [([[5, 7], [4]], [[3, 6], [1], [2]]),
       ([[5, 7], [1]], [[3, 6], [4], [2]]),
       ([[3, 7], [4]], [[5, 6], [1], [2]]),
       ([[3, 7], [1]], [[5, 6], [4], [2]]),
       ([[5, 6], [4]], [[3, 7], [1], [2]]),
       ([[5, 6], [1]], [[3, 7], [4], [2]])]

  Python

      >>> from sage.all import *
      >>> res = RowStandardTableauTuple([[[Integer(3),Integer(6)],[Integer(1)]],[[Integer(5),Integer(7)],[Integer(4)],[Integer(2)]]]).residue_sequence(Integer(3),(Integer(0),Integer(0)))
      >>> tabs = res.row_standard_tableaux([[Integer(2),Integer(1)],[Integer(2),Integer(1),Integer(1)]]); tabs
      Row standard (2,1|2,1^2)-tableaux with 3-residue sequence (2,1,0,2,0,1,1) and multicharge (0,0)
      >>> tabs.shape()
      ([2, 1], [2, 1, 1])
      >>> tabs.level()
      2
      >>> tabs[:Integer(6)]
      [([[5, 7], [4]], [[3, 6], [1], [2]]),
       ([[5, 7], [1]], [[3, 6], [4], [2]]),
       ([[3, 7], [4]], [[5, 6], [1], [2]]),
       ([[3, 7], [1]], [[5, 6], [4], [2]]),
       ([[5, 6], [4]], [[3, 7], [1], [2]]),
       ([[5, 6], [1]], [[3, 7], [4], [2]])]

class sage.combinat.tableau_tuple.RowStandardTableauTuples_shape(shape)

  Bases: `RowStandardTableauTuples`

  Class of all `RowStandardTableauTuples` of a fixed shape.

  an_element()

    Return a particular element of `self`.

    EXAMPLES:

    Sage

        sage: RowStandardTableauTuples([[2],[2,1]]).an_element()                    # needs sage.graphs
        ([[4, 5]], [[1, 3], [2]])
        sage: RowStandardTableauTuples([[10],[],[]]).an_element()                   # needs sage.graphs
        ([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [], [])

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuples([[Integer(2)],[Integer(2),Integer(1)]]).an_element()                    # needs sage.graphs
        ([[4, 5]], [[1, 3], [2]])
        >>> RowStandardTableauTuples([[Integer(10)],[],[]]).an_element()                   # needs sage.graphs
        ([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [], [])

  cardinality()

    Return the number of row standard tableau tuples of with the same shape as the partition tuple `self`.

    This is just the index of the corresponding Young subgroup in the full symmetric group.

    EXAMPLES:

    Sage

        sage: RowStandardTableauTuples([[3,2,1],[]]).cardinality()
        60
        sage: RowStandardTableauTuples([[1],[1],[1]]).cardinality()
        6
        sage: RowStandardTableauTuples([[2,1],[1],[1]]).cardinality()
        60

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuples([[Integer(3),Integer(2),Integer(1)],[]]).cardinality()
        60
        >>> RowStandardTableauTuples([[Integer(1)],[Integer(1)],[Integer(1)]]).cardinality()
        6
        >>> RowStandardTableauTuples([[Integer(2),Integer(1)],[Integer(1)],[Integer(1)]]).cardinality()
        60

class sage.combinat.tableau_tuple.RowStandardTableauTuples_size(size)

  Bases: `RowStandardTableauTuples`, `DisjointUnionEnumeratedSets`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

        sage: RowStandardTableauTuples(size=2).an_element()
        ([[1]], [[2]], [], [])
        sage: RowStandardTableauTuples(size=4).an_element()
        ([[1]], [[2, 3, 4]], [], [])

    Python

        >>> from sage.all import *
        >>> RowStandardTableauTuples(size=Integer(2)).an_element()
        ([[1]], [[2]], [], [])
        >>> RowStandardTableauTuples(size=Integer(4)).an_element()
        ([[1]], [[2, 3, 4]], [], [])

class sage.combinat.tableau_tuple.StandardTableauTuple(parent, t, check=True)

  Bases: `RowStandardTableauTuple`

  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.

  > > 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 sage: StandardTableauTuple([[1,2,3],[4,5]]) in RowStandardTableauTuples() True

  > 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: a `StandardTableauTuple` object constructed from `t`

  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 coordinates `[k,r,c]` in a `TableauTuple` refer to the component, row and column indices, respectively.

  EXAMPLES:

  Sage

      sage: t = TableauTuple([ [[1,3,4],[7,9]], [[2,8,11],[6]], [[5,10]] ])
      sage: 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 printing
        4  5
        7
      sage: t.is_standard()
      True
      sage: t[0].is_standard()
      False
      sage: StandardTableauTuple([[],[],[]]) # An empty tableau tuple
      ([], [], [])

  Python

      >>> from sage.all import *
      >>> t = TableauTuple([ [[Integer(1),Integer(3),Integer(4)],[Integer(7),Integer(9)]], [[Integer(2),Integer(8),Integer(11)],[Integer(6)]], [[Integer(5),Integer(10)]] ])
      >>> t
      ([[1, 3, 4], [7, 9]], [[2, 8, 11], [6]], [[5, 10]])
      >>> t[Integer(0)][Integer(0)][Integer(0)]
      1
      >>> t[Integer(1)][Integer(1)][Integer(0)]
      6
      >>> t[Integer(2)][Integer(0)][Integer(0)]
      5
      >>> t[Integer(2)][Integer(0)][Integer(1)]
      10

      >>> t = StandardTableauTuple([[[Integer(4),Integer(5)],[Integer(7)]],[[Integer(1),Integer(2),Integer(3)],[Integer(6),Integer(8)]],[[Integer(9)]]]); t
      ([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])
      >>> t.pp()
        4  5     1  2  3     9
        7        6  8
      >>> t.shape()
      ([2, 1], [3, 2], [1])
      >>> t[Integer(0)].pp()  # pretty printing
        4  5
        7
      >>> t.is_standard()
      True
      >>> t[Integer(0)].is_standard()
      False
      >>> 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

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

  [Python]

      >>> from sage.all import *
      >>> STT = StandardTableauTuples()
      >>> STT([[[Integer(4),Integer(5)],[Integer(7)]],[[Integer(1),Integer(2),Integer(3)],[Integer(6),Integer(8)]],[[Integer(9)]]])
      ([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])

  See also

  - `Tableau`

  - `Tableaux`

  - `TableauTuples`

  - `TableauTuple`

  - `StandardTableauTuples`

  dominates(t)

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> s = StandardTableauTuple([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]])
        >>> t = StandardTableauTuple([[Integer(1),Integer(2)],[Integer(3),Integer(5)],[Integer(4)]])
        >>> s.dominates(t)
        True
        >>> t.dominates(s)
        False

  restrict(m=None)

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(6))
        ([[5]], [[1, 2], [3, 4]])
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(5))
        ([[5]], [[1, 2], [3, 4]])
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(4))
        ([], [[1, 2], [3, 4]])
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3))
        ([], [[1, 2], [3]])
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(2))
        ([], [[1, 2]])
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(1))
        ([], [[1]])
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(0))
        ([], [])

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

    Sage

        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

    [Python]

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3)).category()
        Category of elements of Tableau tuples
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3)).category()
        Category of elements of Standard tableau tuples
        >>> StandardTableauTuples([[Integer(1)],[Integer(2),Integer(2)]])([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3)).category()
        Category of elements of Standard tableau tuples
        >>> StandardTableauTuples(level=Integer(2))([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3)).category()
        Category of elements of Standard tableau tuples of level 2

  to_chain()

    Return the chain of partitions corresponding to the standard tableau tuple `self`.

    EXAMPLES:

    Sage

        sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).to_chain()
        [([], []),
          ([], [1]),
          ([], [2]),
          ([], [2, 1]),
          ([], [2, 2]),
          ([1], [2, 2])]

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).to_chain()
        [([], []),
          ([], [1]),
          ([], [2]),
          ([], [2, 1]),
          ([], [2, 2]),
          ([1], [2, 2])]

class sage.combinat.tableau_tuple.StandardTableauTuples

  Bases: `RowStandardTableauTuples`

  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` – 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 the 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 right 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

      sage: tabs=StandardTableauTuples([[3],[2,2]]); tabs
      Standard tableau tuples of shape ([3], [2, 2])
      sage: tabs.cardinality()
      70
      sage: tabs[10:16]
      [([[1, 2, 3]], [[4, 6], [5, 7]]),
       ([[1, 2, 4]], [[3, 6], [5, 7]]),
       ([[1, 3, 4]], [[2, 6], [5, 7]]),
       ([[2, 3, 4]], [[1, 6], [5, 7]]),
       ([[1, 2, 5]], [[3, 6], [4, 7]]),
       ([[1, 3, 5]], [[2, 6], [4, 7]])]

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

      sage: StandardTableauTuples()[0]                                                # needs sage.libs.flint
      ()

  Python

      >>> from sage.all import *
      >>> tabs=StandardTableauTuples([[Integer(3)],[Integer(2),Integer(2)]]); tabs
      Standard tableau tuples of shape ([3], [2, 2])
      >>> tabs.cardinality()
      70
      >>> tabs[Integer(10):Integer(16)]
      [([[1, 2, 3]], [[4, 6], [5, 7]]),
       ([[1, 2, 4]], [[3, 6], [5, 7]]),
       ([[1, 3, 4]], [[2, 6], [5, 7]]),
       ([[2, 3, 4]], [[1, 6], [5, 7]]),
       ([[1, 2, 5]], [[3, 6], [4, 7]]),
       ([[1, 3, 5]], [[2, 6], [4, 7]])]

      >>> tabs=StandardTableauTuples(level=Integer(3)); tabs
      Standard tableau tuples of level 3
      >>> tabs[Integer(100)]                                                                 # needs sage.libs.flint
      ([[1, 2], [3]], [], [[4]])

      >>> StandardTableauTuples()[Integer(0)]                                                # needs sage.libs.flint
      ()

  See also

  - `TableauTuples`

  - `Tableau`

  - `StandardTableau`

  - `StandardTableauTuples`

  Element

    alias of `StandardTableauTuple`

  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

        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

    Python

        >>> from sage.all import *
        >>> tabs=StandardTableauTuples(shape=[[Integer(5),Integer(2)],[Integer(3),Integer(2)],[],[Integer(1),Integer(1),Integer(1)],[Integer(3)]]); tabs
        Standard tableau tuples of shape ([5, 2], [3, 2], [], [1, 1, 1], [3])
        >>> tabs.shape()
        ([5, 2], [3, 2], [], [1, 1, 1], [3])
        >>> StandardTableauTuples().shape() is None
        True

class sage.combinat.tableau_tuple.StandardTableauTuples_all

  Bases: `StandardTableauTuples`, `DisjointUnionEnumeratedSets`

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

class sage.combinat.tableau_tuple.StandardTableauTuples_level(level)

  Bases: `StandardTableauTuples`, `DisjointUnionEnumeratedSets`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples(size=Integer(2)).an_element()
        ([[1]], [[2]], [], [])
        >>> StandardTableauTuples(size=Integer(4)).an_element()
        ([[1]], [[2, 3, 4]], [], [])

class sage.combinat.tableau_tuple.StandardTableauTuples_level_size(level, size)

  Bases: `StandardTableauTuples`, `DisjointUnionEnumeratedSets`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

        sage: StandardTableauTuples(5, size=2).an_element()                         # needs sage.libs.flint
        ([], [], [], [], [[1], [2]])
        sage: StandardTableauTuples(2, size=4).an_element()                         # needs sage.libs.flint
        ([[1]], [[2, 3], [4]])

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples(Integer(5), size=Integer(2)).an_element()                         # needs sage.libs.flint
        ([], [], [], [], [[1], [2]])
        >>> StandardTableauTuples(Integer(2), size=Integer(4)).an_element()                         # needs sage.libs.flint
        ([[1]], [[2, 3], [4]])

  cardinality()

    Return the number of elements in this set of tableaux.

    EXAMPLES:

    Sage

        sage: StandardTableauTuples(3,2).cardinality()                              # needs sage.libs.flint
        12
        sage: StandardTableauTuples(4,6).cardinality()                              # needs sage.libs.flint
        31936

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples(Integer(3),Integer(2)).cardinality()                              # needs sage.libs.flint
        12
        >>> StandardTableauTuples(Integer(4),Integer(6)).cardinality()                              # needs sage.libs.flint
        31936

class sage.combinat.tableau_tuple.StandardTableauTuples_shape(shape)

  Bases: `StandardTableauTuples`

  Class of all `StandardTableauTuples` of a fixed shape.

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples([[Integer(2)],[Integer(2),Integer(1)]]).an_element()
        ([[2, 4]], [[1, 3], [5]])
        >>> StandardTableauTuples([[Integer(10)],[],[]]).an_element()
        ([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [], [])

  cardinality()

    Return 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

        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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples([[Integer(3),Integer(2),Integer(1)],[]]).cardinality()
        16
        >>> StandardTableauTuples([[Integer(1)],[Integer(1)],[Integer(1)]]).cardinality()
        6
        >>> StandardTableauTuples([[Integer(2),Integer(1)],[Integer(1)],[Integer(1)]]).cardinality()
        40
        >>> StandardTableauTuples([[Integer(3),Integer(2),Integer(1)],[Integer(3),Integer(2)]]).cardinality()
        36960

  last()

    Return 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

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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples([[Integer(2)],[Integer(2),Integer(2)]]).last().pp()
          5  6     1  3
                   2  4

  random_element()

    Return 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 is more efficient to keep track of the (changing) list of addable nodes as we go.

    EXAMPLES:

    Sage

        sage: StandardTableauTuples([[2],[2,1]]).random_element()  # random
        ([[1, 2]], [[3, 4], [5]])

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples([[Integer(2)],[Integer(2),Integer(1)]]).random_element()  # random
        ([[1, 2]], [[3, 4], [5]])

class sage.combinat.tableau_tuple.StandardTableauTuples_size(size)

  Bases: `StandardTableauTuples`, `DisjointUnionEnumeratedSets`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples(size=Integer(2)).an_element()
        ([[1]], [[2]], [], [])
        >>> StandardTableauTuples(size=Integer(4)).an_element()
        ([[1]], [[2, 3, 4]], [], [])

class sage.combinat.tableau_tuple.StandardTableaux_residue(residue)

  Bases: `StandardTableauTuples`

  Class of all standard tableau tuples with a fixed residue sequence.

  Implicitly, this also specifies the quantum characteristic, multicharge and hence the level and size of the tableaux.

  Note

  This class is not intended to be called directly, but rather, it is accessed through the standard tableaux.

  EXAMPLES:

  Sage

      sage: StandardTableau([[1,2,3],[4,5]]).residue_sequence(2).standard_tableaux()
      Standard tableaux with 2-residue sequence (0,1,0,1,0) and multicharge (0)
      sage: StandardTableau([[1,2,3],[4,5]]).residue_sequence(3).standard_tableaux()
      Standard tableaux with 3-residue sequence (0,1,2,2,0) and multicharge (0)
      sage: StandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(2,(0,0)).standard_tableaux()
      Standard tableaux with 2-residue sequence (0,1,0,1,0,1,1) and multicharge (0,0)
      sage: StandardTableauTuple([[[5,6],[7]],[[1,2,3],[4]]]).residue_sequence(3,(0,1)).standard_tableaux()
      Standard tableaux with 3-residue sequence (1,2,0,0,0,1,2) and multicharge (0,1)

  Python

      >>> from sage.all import *
      >>> StandardTableau([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]]).residue_sequence(Integer(2)).standard_tableaux()
      Standard tableaux with 2-residue sequence (0,1,0,1,0) and multicharge (0)
      >>> StandardTableau([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]]).residue_sequence(Integer(3)).standard_tableaux()
      Standard tableaux with 3-residue sequence (0,1,2,2,0) and multicharge (0)
      >>> StandardTableauTuple([[[Integer(5),Integer(6)],[Integer(7)]],[[Integer(1),Integer(2),Integer(3)],[Integer(4)]]]).residue_sequence(Integer(2),(Integer(0),Integer(0))).standard_tableaux()
      Standard tableaux with 2-residue sequence (0,1,0,1,0,1,1) and multicharge (0,0)
      >>> StandardTableauTuple([[[Integer(5),Integer(6)],[Integer(7)]],[[Integer(1),Integer(2),Integer(3)],[Integer(4)]]]).residue_sequence(Integer(3),(Integer(0),Integer(1))).standard_tableaux()
      Standard tableaux with 3-residue sequence (1,2,0,0,0,1,2) and multicharge (0,1)

class sage.combinat.tableau_tuple.StandardTableaux_residue_shape(residue, shape)

  Bases: `StandardTableaux_residue`

  All standard tableau tuples with a fixed residue and shape.

  INPUT:

  - `shape` – the shape of the partitions or partition tuples

  - `residue` – the residue sequence of the label

  EXAMPLES:

  Sage

      sage: res = StandardTableauTuple([[[1,3],[6]],[[2,7],[4],[5]]]).residue_sequence(3,(0,0))
      sage: tabs = res.standard_tableaux([[2,1],[2,1,1]]); tabs
      Standard (2,1|2,1^2)-tableaux with 3-residue sequence (0,0,1,2,1,2,1) and multicharge (0,0)
      sage: tabs.shape()
      ([2, 1], [2, 1, 1])
      sage: tabs.level()
      2
      sage: tabs[:6]
      [([[2, 7], [6]], [[1, 3], [4], [5]]),
       ([[1, 7], [6]], [[2, 3], [4], [5]]),
       ([[2, 3], [6]], [[1, 7], [4], [5]]),
       ([[1, 3], [6]], [[2, 7], [4], [5]]),
       ([[2, 5], [6]], [[1, 3], [4], [7]]),
       ([[1, 5], [6]], [[2, 3], [4], [7]])]

  Python

      >>> from sage.all import *
      >>> res = StandardTableauTuple([[[Integer(1),Integer(3)],[Integer(6)]],[[Integer(2),Integer(7)],[Integer(4)],[Integer(5)]]]).residue_sequence(Integer(3),(Integer(0),Integer(0)))
      >>> tabs = res.standard_tableaux([[Integer(2),Integer(1)],[Integer(2),Integer(1),Integer(1)]]); tabs
      Standard (2,1|2,1^2)-tableaux with 3-residue sequence (0,0,1,2,1,2,1) and multicharge (0,0)
      >>> tabs.shape()
      ([2, 1], [2, 1, 1])
      >>> tabs.level()
      2
      >>> tabs[:Integer(6)]
      [([[2, 7], [6]], [[1, 3], [4], [5]]),
       ([[1, 7], [6]], [[2, 3], [4], [5]]),
       ([[2, 3], [6]], [[1, 7], [4], [5]]),
       ([[1, 3], [6]], [[2, 7], [4], [5]]),
       ([[2, 5], [6]], [[1, 3], [4], [7]]),
       ([[1, 5], [6]], [[2, 3], [4], [7]])]

  an_element()

    Return a particular element of `self`.

    EXAMPLES:

    Sage

        sage: T = StandardTableau([[1,3],[2]]).residue_sequence(3).standard_tableaux([2,1])
        sage: T.an_element()
        [[1, 3], [2]]

    Python

        >>> from sage.all import *
        >>> T = StandardTableau([[Integer(1),Integer(3)],[Integer(2)]]).residue_sequence(Integer(3)).standard_tableaux([Integer(2),Integer(1)])
        >>> T.an_element()
        [[1, 3], [2]]

class sage.combinat.tableau_tuple.TableauTuple(parent, t, check=True)

  Bases: `CombinatorialElement`

  A class to model a tuple of tableaux.

  INPUT:

  - `t` – 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, [DJM1998]

  - the crystal theory of (quantum) affine special linear groups and its integral highest weight modules and their canonical bases. See, for example, [BK2009].

  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 and behaves like a real tuple of (level 1) `Tableaux`. Many of the operations which are defined on `Tableau` extend to `TableauTuples`. Tableau tuples 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-tuple of tableaux the tableau itself is returned.

  EXAMPLES:

  Sage

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

  Python

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

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

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

      >>> TableauTuple([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]])
      [[1, 2, 3], [4, 5]]
      >>> TableauTuple([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]]) == Tableau([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]])
      True

  See also

  - `StandardTableauTuple`

  - `StandardTableauTuples`

  - `StandardTableau`

  - `StandardTableaux`

  - `TableauTuple`

  - `TableauTuples`

  - `Tableau`

  - `Tableaux`

  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

        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

    Python

        >>> from sage.all import *
        >>> s = StandardTableauTuple([ [[Integer(3),Integer(4),Integer(7)],[Integer(6),Integer(8)]], [[Integer(9),Integer(13)],[Integer(12)]], [[Integer(1),Integer(5)],[Integer(2),Integer(11)],[Integer(10)]] ]); s.pp()
          3  4  7     9 13     1  5
          6  8       12        2 11
                              10
        >>> t = s.add_entry( (Integer(0),Integer(0),Integer(3)),Integer(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
        >>> t = s.add_entry( (Integer(0),Integer(0),Integer(3)),Integer(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
        >>> t = s.add_entry( (Integer(1),Integer(1),Integer(1)),Integer(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
        >>> t = s.add_entry( (Integer(2),Integer(1),Integer(1)),Integer(14)); t.pp(); t.category()
          3  4  7     9 13     1  5
          6  8       12        2 14
                              10
        Category of elements of Tableau tuples
        >>> t = s.add_entry( (Integer(2),Integer(1),Integer(2)),Integer(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)

    Return 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

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

    Python

        >>> from sage.all import *
        >>> t = TableauTuple([[[Integer(4),Integer(5)]],[[Integer(1),Integer(1),Integer(2),Integer(4)],[Integer(2),Integer(4),Integer(4)],[Integer(4)]],[[Integer(1),Integer(3),Integer(4)],[Integer(3),Integer(4)]]])
        >>> t.cells_containing(Integer(4))
        [(0, 0, 0),
          (1, 2, 0),
          (1, 1, 1),
          (1, 1, 2),
          (1, 0, 3),
          (2, 1, 1),
          (2, 0, 2)]
        >>> t.cells_containing(Integer(6))
        []

  charge()

    Return the charge of the reading word of `self`.

    See `charge()` for more information.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(4),Integer(5)]],[[Integer(1),Integer(1),Integer(2),Integer(4)],[Integer(2),Integer(4),Integer(4)],[Integer(4)]],[[Integer(1),Integer(3),Integer(4)],[Integer(3),Integer(4)]]]).charge()
        4

  cocharge()

    Return the cocharge of the reading word of `self`.

    See `cocharge()` for more information.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(4),Integer(5)]],[[Integer(1),Integer(1),Integer(2),Integer(4)],[Integer(2),Integer(4),Integer(4)],[Integer(4)]],[[Integer(1),Integer(3),Integer(4)],[Integer(3),Integer(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

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

    Python

        >>> from sage.all import *
        >>> # needs sage.groups
        >>> t = TableauTuple([[[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]],[[Integer(6),Integer(7)]],[[Integer(8)],[Integer(9)]]])
        >>> cs = t.column_stabilizer()
        >>> cs.order()
        8
        >>> PermutationGroupElement([(Integer(1),Integer(3),Integer(2)),(Integer(4),Integer(5))]) in cs
        False
        >>> PermutationGroupElement([(Integer(1),Integer(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

        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

    Python

        >>> from sage.all import *
        >>> for t in TableauTuple([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]]).components(): t.pp()
          1  2  3
          4  5
        >>> for t in TableauTuple([ [[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]], [[Integer(6),Integer(7)],[Integer(8),Integer(9)]] ]).components(): t.pp()
          1  2  3
          4  5
          6  7
          8  9

  conjugate()

    Return the conjugate of the tableau tuple `self`.

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).conjugate()
        ([[9, 11, 12], [10]], [[5, 8], [6], [7]], [[1, 3], [2, 4]])

  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 + a_k\), where the multicharge is \((a_1, a_2, \ldots, a_l)\) and \(l\) is the level of the tableau.

    The multicharge determines the dominant weight

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

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

    INPUT:

    - `k` – integer in \(\{1, 2, \ldots, n\}\)

    - `multicharge` – a sequence of integers of length \(l\)

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).content(Integer(3),[Integer(0),Integer(0)])
        -1
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).content(Integer(3),[Integer(0),Integer(1)])
        0
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).content(Integer(3),[Integer(0),Integer(2)])
        1
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).content(Integer(6),[Integer(0),Integer(2)])
        Traceback (most recent call last):
        ...
        ValueError: 6 must be contained in the tableaux

  entries()

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

    EXAMPLES:

    Sage

        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]

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).entries()
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]]]).entries()
        [1, 2, 3, 4, 9, 10, 11, 12, 5, 6, 7, 8]

  entry(l, r, c)

    Return 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

        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: tuple index out of range

    Python

        >>> from sage.all import *
        >>> t = TableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]])
        >>> t.entry(Integer(1), Integer(0), Integer(0))
        5
        >>> t.entry(Integer(1), Integer(1), Integer(1))
        Traceback (most recent call last):
        ...
        IndexError: tuple index out of range

  first_column_descent()

    Return the first cell of `self` is not column standard.

    Cells are ordered left to right along the rows and then top to bottom. That is, return the cell \((k,r,c)\) with \((k,r,c)\) minimal such that the entry in position \((k,r,c)\) is bigger than the entry in position \((k,r,c+1)\). If there is no such cell then `None` is returned - in this case the tableau is column strict.

    OUTPUT:

    The cell corresponding to the first column descent or `None` if the tableau is column strict.

    EXAMPLES:

    Sage

        sage: TableauTuple([[[3,5,6],[2,4,5]],[[1,4,5],[2,3]]]).first_column_descent()
        (0, 0, 0)
        sage: Tableau([[[1,2,3],[4]],[[5,6,7],[8,9]]]).first_column_descent() is None
        True

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(3),Integer(5),Integer(6)],[Integer(2),Integer(4),Integer(5)]],[[Integer(1),Integer(4),Integer(5)],[Integer(2),Integer(3)]]]).first_column_descent()
        (0, 0, 0)
        >>> Tableau([[[Integer(1),Integer(2),Integer(3)],[Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8),Integer(9)]]]).first_column_descent() is None
        True

  first_row_descent()

    Return the first cell of `self` that is not row standard.

    Cells are ordered left to right along the rows and then top to bottom. That is, the cell minimal \((k,r,c)\) such that the entry in position \((k,r,c)\) is bigger than the entry in position \((k,r,c+1)\). If there is no such cell then `None` is returned - in this case the tableau is row strict.

    OUTPUT:

    The cell corresponding to the first row descent or `None` if the tableau is row strict.

    EXAMPLES:

    Sage

        sage: TableauTuple([[[5,6,7],[1,2]],[[1,3,2],[4]]]).first_row_descent()
        (1, 0, 1)
        sage: TableauTuple([[[1,2,3],[4]],[[6,7,8],[1,2,3]],[[1,11]]]).first_row_descent() is None
        True

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(5),Integer(6),Integer(7)],[Integer(1),Integer(2)]],[[Integer(1),Integer(3),Integer(2)],[Integer(4)]]]).first_row_descent()
        (1, 0, 1)
        >>> TableauTuple([[[Integer(1),Integer(2),Integer(3)],[Integer(4)]],[[Integer(6),Integer(7),Integer(8)],[Integer(1),Integer(2),Integer(3)]],[[Integer(1),Integer(11)]]]).first_row_descent() is None
        True

  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

        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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(5),Integer(7)],[Integer(8)]],[[Integer(1), Integer(3)], [Integer(2), Integer(4)]],[[Integer(6)]]]).is_column_strict()
        True
        >>> TableauTuple([[[Integer(1), Integer(2)], [Integer(2), Integer(4)]],[[Integer(4),Integer(5),Integer(6)],[Integer(7),Integer(8)]]]).is_column_strict()
        True
        >>> TableauTuple([[[Integer(1)]],[[Integer(2), Integer(3)], [Integer(2), Integer(4)]]]).is_column_strict()
        False
        >>> TableauTuple([[[Integer(1)]],[[Integer(2), Integer(2)], [Integer(4),Integer(5)]]]).is_column_strict()
        True
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(6),Integer(7)]],[[Integer(4),Integer(8)], [Integer(6), Integer(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

        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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(5),Integer(7)],[Integer(8)]],[[Integer(1), Integer(3)], [Integer(2), Integer(4)]],[[Integer(6)]]]).is_row_strict()
        True
        >>> TableauTuple([[[Integer(1), Integer(2)], [Integer(2), Integer(4)]],[[Integer(4),Integer(5),Integer(6)],[Integer(7),Integer(8)]]]).is_row_strict()
        True
        >>> TableauTuple([[[Integer(1)]],[[Integer(2), Integer(3)], [Integer(2), Integer(4)]]]).is_row_strict()
        True
        >>> TableauTuple([[[Integer(1)]],[[Integer(2), Integer(2)], [Integer(4),Integer(5)]]]).is_row_strict()
        False
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(6),Integer(7)]],[[Integer(4),Integer(8)], [Integer(6), Integer(9)]],[]]).is_row_strict()
        True

  is_standard()

    Return `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

        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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(5),Integer(7)],[Integer(8)]],[[Integer(1), Integer(3)], [Integer(2), Integer(4)]],[[Integer(6)]]]).is_standard()
        True
        >>> TableauTuple([[[Integer(1), Integer(2)], [Integer(2), Integer(4)]],[[Integer(4),Integer(5),Integer(6)],[Integer(7),Integer(8)]]]).is_standard()
        False
        >>> TableauTuple([[[Integer(1)]],[[Integer(2), Integer(3)], [Integer(2), Integer(4)]]]).is_standard()
        False
        >>> TableauTuple([[[Integer(1)]],[[Integer(2), Integer(2)], [Integer(4),Integer(5)]]]).is_row_strict()
        False
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(6),Integer(7)]],[[Integer(4),Integer(8)], [Integer(6), Integer(9)]],[]]).is_standard()
        False

  level()

    Return the level of the tableau `self`.

    This is just the number of components in the tableau tuple `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(7),Integer(8),Integer(9)]],[],[[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)],[Integer(6)]]]).level()
        3

  pp()

    Pretty printing for the tableau tuple `self`.

    EXAMPLES:

    Sage

        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.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.options._reset()

    Python

        >>> from sage.all import *
        >>> TableauTuple([ [[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]], [[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]] ]).pp()
          1  2  3     1  2  3
          4  5        4  5
        >>> TableauTuple([ [[Integer(1),Integer(2)],[Integer(3)],[Integer(4)]],[],[[Integer(6),Integer(7),Integer(8)],[Integer(10),Integer(11)],[Integer(12)],[Integer(13)]]]).pp()
          1  2     -     6  7  8
          3             10 11
          4             12
                        13
        >>> t = TableauTuple([ [[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)],[Integer(6)],[Integer(9)]], [[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5),Integer(8)]], [[Integer(11),Integer(12),Integer(13)],[Integer(14)]] ])
        >>> t.pp()
          1  2  3     1  2  3    11 12 13
          4  5        4  5  8    14
          6
          9
        >>> TableauTuples.options(convention='french')
        >>> t.pp()
          9
          6
          4  5        4  5  8    14
          1  2  3     1  2  3    11 12 13
        >>> TableauTuples.options._reset()

  reduced_column_word()

    Return the lexicographically minimal reduced expression for the permutation that maps the `initial_column_tableau()` to `self`.

    This reduced expression is a minimal length coset representative for the corresponding Young subgroup. In one line notation, the permutation is obtained by concatenating the rows of the tableau from top to bottom in each component, and then left to right along the components.

    EXAMPLES:

    Sage

        sage: StandardTableauTuple([[[7,9],[8]],[[1,4,6],[2,5],[3]]]).reduced_column_word()
        []
        sage: StandardTableauTuple([[[7,9],[8]],[[1,3,6],[2,5],[4]]]).reduced_column_word()
        [3]
        sage: StandardTableauTuple([[[6,9],[8]],[[1,3,7],[2,5],[4]]]).reduced_column_word()
        [3, 6]
        sage: StandardTableauTuple([[[6,8],[9]],[[1,3,7],[2,5],[4]]]).reduced_column_word()
        [3, 6, 8]
        sage: StandardTableauTuple([[[5,8],[9]],[[1,3,7],[2,6],[4]]]).reduced_column_word()
        [3, 6, 5, 8]

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(7),Integer(9)],[Integer(8)]],[[Integer(1),Integer(4),Integer(6)],[Integer(2),Integer(5)],[Integer(3)]]]).reduced_column_word()
        []
        >>> StandardTableauTuple([[[Integer(7),Integer(9)],[Integer(8)]],[[Integer(1),Integer(3),Integer(6)],[Integer(2),Integer(5)],[Integer(4)]]]).reduced_column_word()
        [3]
        >>> StandardTableauTuple([[[Integer(6),Integer(9)],[Integer(8)]],[[Integer(1),Integer(3),Integer(7)],[Integer(2),Integer(5)],[Integer(4)]]]).reduced_column_word()
        [3, 6]
        >>> StandardTableauTuple([[[Integer(6),Integer(8)],[Integer(9)]],[[Integer(1),Integer(3),Integer(7)],[Integer(2),Integer(5)],[Integer(4)]]]).reduced_column_word()
        [3, 6, 8]
        >>> StandardTableauTuple([[[Integer(5),Integer(8)],[Integer(9)]],[[Integer(1),Integer(3),Integer(7)],[Integer(2),Integer(6)],[Integer(4)]]]).reduced_column_word()
        [3, 6, 5, 8]

  reduced_row_word()

    Return the lexicographically minimal reduced expression for the permutation that maps the `initial_tableau()` to `self`.

    This reduced expression is a minimal length coset representative for the corresponding Young subgroup. In one line notation, the permutation is obtained by concatenating the rows of the tableau from top to bottom in each component, and then left to right along the components.

    EXAMPLES:

    Sage

        sage: StandardTableauTuple([[[1,2],[3]],[[4,5,6],[7,8],[9]]]).reduced_row_word()
        []
        sage: StandardTableauTuple([[[1,2],[3]],[[4,5,6],[7,9],[8]]]).reduced_row_word()
        [8]
        sage: StandardTableauTuple([[[1,2],[3]],[[4,5,7],[6,9],[8]]]).reduced_row_word()
        [6, 8]
        sage: StandardTableauTuple([[[1,2],[3]],[[4,5,8],[6,9],[7]]]).reduced_row_word()
        [6, 8, 7]
        sage: StandardTableauTuple([[[1,2],[3]],[[4,5,9],[6,8],[7]]]).reduced_row_word()
        [6, 7, 8, 7]
        sage: StandardTableauTuple([[[7,9],[8]],[[1,3,5],[2,6],[4]]]).reduced_row_word()
        [2, 3, 2, 1, 4, 3, 2, 5, 4, 3, 6, 5, 4, 3, 2, 7, 6, 5, 8, 7, 6, 5, 4]

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3)]],[[Integer(4),Integer(5),Integer(6)],[Integer(7),Integer(8)],[Integer(9)]]]).reduced_row_word()
        []
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3)]],[[Integer(4),Integer(5),Integer(6)],[Integer(7),Integer(9)],[Integer(8)]]]).reduced_row_word()
        [8]
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3)]],[[Integer(4),Integer(5),Integer(7)],[Integer(6),Integer(9)],[Integer(8)]]]).reduced_row_word()
        [6, 8]
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3)]],[[Integer(4),Integer(5),Integer(8)],[Integer(6),Integer(9)],[Integer(7)]]]).reduced_row_word()
        [6, 8, 7]
        >>> StandardTableauTuple([[[Integer(1),Integer(2)],[Integer(3)]],[[Integer(4),Integer(5),Integer(9)],[Integer(6),Integer(8)],[Integer(7)]]]).reduced_row_word()
        [6, 7, 8, 7]
        >>> StandardTableauTuple([[[Integer(7),Integer(9)],[Integer(8)]],[[Integer(1),Integer(3),Integer(5)],[Integer(2),Integer(6)],[Integer(4)]]]).reduced_row_word()
        [2, 3, 2, 1, 4, 3, 2, 5, 4, 3, 6, 5, 4, 3, 2, 7, 6, 5, 8, 7, 6, 5, 4]

  residue(k, e, multicharge)

    Return the residue of the integer `k` in the tableau `self`.

    The residue of \(k\) is \(c - r + a_k\) in \(\ZZ / e\ZZ\), where \(k\) appears in row \(r\) and column \(c\) of the tableau and the multicharge is \((a_1, a_2, \ldots, a_l)\).

    The multicharge determines the dominant weight

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

    for the affine special linear group. In the combinatorics, it simply offsets the contents in each component so that the cell \((k, 0, 0)\) has content \(a_k\).

    INPUT:

    - `k` – integer in \(\{1, 2, \ldots, n\}\)

    - `e` – integer in \(\{0, 2, 3, 4, 5, \ldots\}\)

    - `multicharge` – list of integers of length \(l\)

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

    OUTPUT: the residue of `k` in a standard tableau. That is,

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue(Integer(1), Integer(3),[Integer(0),Integer(0)])
        0
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue(Integer(1), Integer(3),[Integer(0),Integer(1)])
        1
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue(Integer(1), Integer(3),[Integer(0),Integer(2)])
        2
        >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue(Integer(6), Integer(3),[Integer(0),Integer(2)])
        Traceback (most recent call last):
        ...
        ValueError: 6 must be contained in the tableaux

  restrict(m=None)

    Return 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

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict()
        ([], [[1, 2], [3, 4]])
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(6))
        ([[5]], [[1, 2], [3, 4]])
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(5))
        ([[5]], [[1, 2], [3, 4]])
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(4))
        ([], [[1, 2], [3, 4]])
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3))
        ([], [[1, 2], [3]])
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(2))
        ([], [[1, 2]])
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(1))
        ([], [[1]])
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(0))
        ([], [])

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

    Sage

        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

    [Python]

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3)).category()
        Category of elements of Tableau tuples
        >>> TableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(3)).category()
        Category of elements of Tableau tuples
        >>> TableauTuples(level=Integer(2))([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).restrict(Integer(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

        sage: # needs sage.groups
        sage: t = TableauTuple([[[1,2,3],[4,5]],[[6,7]],[[8],[9]]])
        sage: rs = t.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]

    Python

        >>> from sage.all import *
        >>> # needs sage.groups
        >>> t = TableauTuple([[[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]],[[Integer(6),Integer(7)]],[[Integer(8)],[Integer(9)]]])
        >>> rs = t.row_stabilizer()
        >>> rs.order()
        24
        >>> PermutationGroupElement([(Integer(1),Integer(3),Integer(2)),(Integer(4),Integer(5))]) in rs
        True
        >>> PermutationGroupElement([(Integer(1),Integer(4))]) in rs
        False
        >>> rs.one().domain()
        [1, 2, 3, 4, 5, 6, 7, 8, 9]

  shape()

    Return the `PartitionTuple` which is the shape of the tableau tuple `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(7),Integer(8),Integer(9)]],[],[[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)],[Integer(6)]]]).shape()
        ([3], [], [3, 2, 1])

  size()

    Return the size of the tableau tuple `self`.

    This is just the number of boxes, or the size, of the underlying `PartitionTuple`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(7),Integer(8),Integer(9)]],[],[[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)],[Integer(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

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(4)]],[[Integer(3),Integer(5)]]]).symmetric_group_action_on_entries( Permutation(((Integer(4),Integer(5)))) )
        ([[1, 2], [5]], [[3, 4]])
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(4)]],[[Integer(3),Integer(5)]]]).symmetric_group_action_on_entries( Permutation(((Integer(1),Integer(2)))) )
        ([[2, 1], [4]], [[3, 5]])

  to_list()

    Return the list representation of the tableaux tuple `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuple([ [[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(5)]], [[Integer(6),Integer(7)],[Integer(8),Integer(9)]] ]).to_list()
        [[[1, 2, 3], [4, 5]], [[6, 7], [8, 9]]]

  to_permutation()

    Return a permutation with the entries in the tableau tuple `self`.

    The permutation is obtained from `self` 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

        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]

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).to_permutation()
        [12, 11, 9, 10, 8, 5, 6, 7, 3, 4, 1, 2]

  to_word()

    alias of `to_word_by_row()`.

  to_word_by_column()

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(12)]]]).to_word_by_column()
        word: 12,11,9,10,8,5,6,7,3,1,4,2

  to_word_by_row()

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> TableauTuple([[[Integer(1),Integer(2)],[Integer(3),Integer(4)]],[[Integer(5),Integer(6),Integer(7)],[Integer(8)]],[[Integer(9),Integer(10)],[Integer(11)],[Integer(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

        sage: list(TableauTuple([[[1,2]],[[3]]]).up())
        [([[1, 2, 4]], [[3]]),
          ([[1, 2], [4]], [[3]]),
          ([[1, 2]], [[3, 4]]),
          ([[1, 2]], [[3], [4]])]

    Python

        >>> from sage.all import *
        >>> list(TableauTuple([[[Integer(1),Integer(2)]],[[Integer(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: `UniqueRepresentation`, `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 (nonnegative 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

      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

  Python

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

  See also

  - `Tableau`

  - `StandardTableau`

  - `StandardTableauTuples`

  Element

    alias of `TableauTuple`

  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

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

    Python

        >>> from sage.all import *
        >>> TableauTuples().level() is None
        True
        >>> TableauTuples(Integer(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

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

    Python

        >>> from sage.all import *
        >>> StandardTableauTuples([[Integer(2),Integer(1)],[Integer(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]])]

  options = Current options for Tableaux - ascii_art: repr - convention: English - display: list - latex: diagram
  size()

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

    EXAMPLES:

    Sage

        sage: TableauTuples(size=14).size()
        14

    Python

        >>> from sage.all import *
        >>> TableauTuples(size=Integer(14)).size()
        14

class sage.combinat.tableau_tuple.TableauTuples_all

  Bases: `TableauTuples`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuples().an_element()
        ([[1]], [[2]], [[3]], [[4]], [[5]], [[6]], [[7]])

class sage.combinat.tableau_tuple.TableauTuples_level(level)

  Bases: `TableauTuples`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> TableauTuples(Integer(3)).an_element()
        ([], [], [])
        >>> TableauTuples(Integer(5)).an_element()
        ([], [], [], [], [])
        >>> T = TableauTuples(Integer(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: `TableauTuples`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuples(Integer(3),Integer(0)).an_element()
        ([], [], [])
        >>> TableauTuples(Integer(3),Integer(1)).an_element()
        ([[1]], [], [])
        >>> TableauTuples(Integer(3),Integer(2)).an_element()
        ([[1, 2]], [], [])

class sage.combinat.tableau_tuple.TableauTuples_size(size)

  Bases: `TableauTuples`

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

  an_element()

    Return a particular element of the class.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> TableauTuples(size=Integer(3)).an_element()
        ([], [[1, 2, 3]], [])
        >>> TableauTuples(size=Integer(0)).an_element()
        ([], [], [])