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: 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
>>> 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: 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]])]
>>> 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: 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
>>> 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: StandardTableauTuples()[:10] # needs sage.libs.flint
[(),
([[1]]),
([], []),
([[1, 2]]),
([[1], [2]]),
([[1]], []),
([], [[1]]),
([], [], []),
([[1, 2, 3]]),
([[1, 3], [2]])]
>>> 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.pyby Mike Hansen (2007) and Jason Bandlow (2011).Andrew Mathas (2016-08-11): Row standard tableaux added
Element classes:
Factory classes:
Parent classes:
See also
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)[source]¶
Bases:
TableauTupleA 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 aPartitionTuple.Note
The tableaux appearing in a
RowStandardTableauTupleare row strict, but individually they are not standard tableaux because the entries in any single component of aRowStandardTableauTuplewill 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
RowStandardTableauTupleobject constructed fromtNote
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 aTableauTuplerefer to the component, row and column indices, respectively.EXAMPLES:
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
>>> 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
RowStandardTableauTuplefrom the appropriate parent object:sage: RST = RowStandardTableauTuples() sage: RST([[[4,5],[7]],[[1,2,3],[6,8]],[[9]]]) ([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])
>>> 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
RowTableauRowTableaux
- codegree(e, multicharge)[source]¶
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
selfgives the degree of “dual” homogeneous basis element of the graded Specht module which is indexed byself.INPUT:
e– the quantum characteristicmulticharge– the multicharge
OUTPUT: the codegree of the tableau
self, which is an integerEXAMPLES:
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
>>> 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)[source]¶
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 characteristicemulticharge– (default:[0]) the multicharge
OUTPUT: the degree of the tableau
self, which is an integerEXAMPLES:
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
>>> 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)[source]¶
Return the cell containing
kin the tableau tupleself.EXAMPLES:
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)
>>> 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)[source]¶
Return the
sage.combinat.tableau_residues.ResidueSequenceofself.INPUT:
e– integer in \(\{0, 2, 3, 4, 5, \ldots\}\)multicharge– a sequence of integers of length equal to the level/length ofself
OUTPUT:
The
residue sequenceof the tableau.EXAMPLES:
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)
>>> 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[source]¶
Bases:
TableauTuplesA factory class for the various classes of tuples of row standard tableau.
INPUT:
There are three optional arguments:
level– thelevel()of the tuples of tableauxsize– thesize()of the tuples of tableauxshape– list or a partition tuple specifying theshape()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 thesize()of the tableau tuples.OUTPUT: the appropriate subclass of
RowStandardTableauTuplesA 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: 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 ([])
>>> 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 ([])
- Element[source]¶
alias of
RowStandardTableauTuple
- level_one_parent_class[source]¶
alias of
RowStandardTableaux_all
- shape()[source]¶
Return the shape of the set of
RowStandardTableauTuples, orNoneif it is not defined.EXAMPLES:
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
>>> 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[source]¶
Bases:
RowStandardTableauTuples,DisjointUnionEnumeratedSetsDefault class of all
RowStandardTableauTupleswith an arbitrarylevel()andsize().
- class sage.combinat.tableau_tuple.RowStandardTableauTuples_level(level)[source]¶
Bases:
RowStandardTableauTuples,DisjointUnionEnumeratedSetsClass of all
RowStandardTableauTupleswith a fixedleveland arbitrarysize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: RowStandardTableauTuples(2).an_element() ([[1]], [[2, 3]]) sage: RowStandardTableauTuples(3).an_element() ([[1]], [[2, 3]], [[4, 5, 6, 7]])
>>> 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)[source]¶
Bases:
RowStandardTableauTuples,DisjointUnionEnumeratedSetsClass of all
RowStandardTableauTupleswith a fixedleveland a fixedsize.- an_element()[source]¶
Return a particular element of
self.EXAMPLES:
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]])
>>> 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)[source]¶
Bases:
RowStandardTableauTuplesClass 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: 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)
>>> 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()[source]¶
Return a particular element of
self.EXAMPLES:
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]], [])
>>> 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()[source]¶
Return the level of
self.EXAMPLES:
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
>>> 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()[source]¶
Return the multicharge of
self.EXAMPLES:
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)
>>> 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()[source]¶
Return the quantum characteristic of
self.EXAMPLES:
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
>>> 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()[source]¶
Return the residue sequence of
self.EXAMPLES:
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)
>>> 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()[source]¶
Return the size of
self.EXAMPLES:
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
>>> 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)[source]¶
Bases:
RowStandardTableauTuples_residueAll row standard tableau tuples with a fixed residue and shape.
INPUT:
shape– the shape of the partitions or partition tuplesresidue– the residue sequence of the label
EXAMPLES:
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]])]
>>> 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)[source]¶
Bases:
RowStandardTableauTuplesClass of all
RowStandardTableauTuplesof a fixed shape.- an_element()[source]¶
Return a particular element of
self.EXAMPLES:
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]], [], [])
>>> 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()[source]¶
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: RowStandardTableauTuples([[3,2,1],[]]).cardinality() 60 sage: RowStandardTableauTuples([[1],[1],[1]]).cardinality() 6 sage: RowStandardTableauTuples([[2,1],[1],[1]]).cardinality() 60
>>> 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)[source]¶
Bases:
RowStandardTableauTuples,DisjointUnionEnumeratedSetsClass of all
RowStandardTableauTupleswith an arbitraryleveland a fixedsize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: RowStandardTableauTuples(size=2).an_element() ([[1]], [[2]], [], []) sage: RowStandardTableauTuples(size=4).an_element() ([[1]], [[2, 3, 4]], [], [])
>>> 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)[source]¶
Bases:
RowStandardTableauTupleA 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
StandardTableauTupleare both row and column strict, but individually they are not standard tableaux because the entries in any single component of aStandardTableauTuplewill 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
StandardTableauTupleobject constructed fromtNote
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 aTableauTuplerefer to the component, row and column indices, respectively.EXAMPLES:
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 ([], [], [])
>>> 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
StandardTableauTuplefrom the appropriate parent object:sage: STT = StandardTableauTuples() sage: STT([[[4,5],[7]],[[1,2,3],[6,8]],[[9]]]) ([[4, 5], [7]], [[1, 2, 3], [6, 8]], [[9]])
>>> 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]])
- dominates(t)[source]¶
Return
Trueif the tableau (tuple)selfdominates the tableaut. The two tableaux do not need to be of the same shape.EXAMPLES:
sage: s = StandardTableauTuple([[1,2,3],[4,5]]) sage: t = StandardTableauTuple([[1,2],[3,5],[4]]) sage: s.dominates(t) True sage: t.dominates(s) False
>>> 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)[source]¶
Return the restriction of the standard tableau
selftom, which defaults to one less than the currentsize().EXAMPLES:
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(6) ([[5]], [[1, 2], [3, 4]]) sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(5) ([[5]], [[1, 2], [3, 4]]) sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(4) ([], [[1, 2], [3, 4]]) sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3) ([], [[1, 2], [3]]) sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(2) ([], [[1, 2]]) sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(1) ([], [[1]]) sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).restrict(0) ([], [])
>>> 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: 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
>>> 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()[source]¶
Return the chain of partitions corresponding to the standard tableau tuple
self.EXAMPLES:
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).to_chain() [([], []), ([], [1]), ([], [2]), ([], [2, 1]), ([], [2, 2]), ([1], [2, 2])]
>>> 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[source]¶
Bases:
RowStandardTableauTuplesA factory class for the various classes of tuples of standard tableau.
INPUT:
There are three optional arguments:
level– thelevel()of the tuples of tableauxsize– thesize()of the tuples of tableauxshape– list or a partition tuple specifying theshape()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 thesize()of the tableau tuples.OUTPUT: the appropriate subclass of
StandardTableauTuplesA 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: 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 ()
>>> 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 ()
- Element[source]¶
alias of
StandardTableauTuple
- level_one_parent_class[source]¶
alias of
StandardTableaux_all
- shape()[source]¶
Return the shape of the set of
StandardTableauTuples, orNoneif it is not defined.EXAMPLES:
sage: tabs=StandardTableauTuples(shape=[[5,2],[3,2],[],[1,1,1],[3]]); tabs Standard tableau tuples of shape ([5, 2], [3, 2], [], [1, 1, 1], [3]) sage: tabs.shape() ([5, 2], [3, 2], [], [1, 1, 1], [3]) sage: StandardTableauTuples().shape() is None True
>>> 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[source]¶
Bases:
StandardTableauTuples,DisjointUnionEnumeratedSetsDefault class of all
StandardTableauTupleswith an arbitrarylevel()andsize().
- class sage.combinat.tableau_tuple.StandardTableauTuples_level(level)[source]¶
Bases:
StandardTableauTuples,DisjointUnionEnumeratedSetsClass of all
StandardTableauTupleswith a fixedleveland arbitrarysize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: StandardTableauTuples(size=2).an_element() ([[1]], [[2]], [], []) sage: StandardTableauTuples(size=4).an_element() ([[1]], [[2, 3, 4]], [], [])
>>> 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)[source]¶
Bases:
StandardTableauTuples,DisjointUnionEnumeratedSetsClass of all
StandardTableauTupleswith a fixedleveland a fixedsize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
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]])
>>> 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()[source]¶
Return the number of elements in this set of tableaux.
EXAMPLES:
sage: StandardTableauTuples(3,2).cardinality() # needs sage.libs.flint 12 sage: StandardTableauTuples(4,6).cardinality() # needs sage.libs.flint 31936
>>> 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)[source]¶
Bases:
StandardTableauTuplesClass of all
StandardTableauTuplesof a fixed shape.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: StandardTableauTuples([[2],[2,1]]).an_element() ([[2, 4]], [[1, 3], [5]]) sage: StandardTableauTuples([[10],[],[]]).an_element() ([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [], [])
>>> 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()[source]¶
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
shapeof the tableaux inselfand let \(m_k=|\mu^{(k)}|\), for \(1\le k\le l\). Multiplying by a (unique) coset representative of the Young subgroup \(S_{m_1}\times\dots\times S_{m_l}\) inside the symmetric group \(S_n\), we can assume that \(t\) is standard and the numbers \(1,2...,n\) are entered in order from to right along the components of the tableau. Therefore, there are\[\binom{n}{m_1,\dots,m_l}\prod_{k=1}^l |\text{Std}(\mu^{(k)})|\]standard tableau tuples of this shape, where \(|\text{Std}(\mu^{(k)})|\) is the number of standard tableau of shape \(\mu^{(k)}\), for \(1 \leq k \leq l\). This is given by the hook length formula.
EXAMPLES:
sage: StandardTableauTuples([[3,2,1],[]]).cardinality() 16 sage: StandardTableauTuples([[1],[1],[1]]).cardinality() 6 sage: StandardTableauTuples([[2,1],[1],[1]]).cardinality() 40 sage: StandardTableauTuples([[3,2,1],[3,2]]).cardinality() 36960
>>> 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()[source]¶
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: StandardTableauTuples([[2],[2,2]]).last().pp() 5 6 1 3 2 4
>>> from sage.all import * >>> StandardTableauTuples([[Integer(2)],[Integer(2),Integer(2)]]).last().pp() 5 6 1 3 2 4
- random_element()[source]¶
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: StandardTableauTuples([[2],[2,1]]).random_element() # random ([[1, 2]], [[3, 4], [5]])
>>> 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)[source]¶
Bases:
StandardTableauTuples,DisjointUnionEnumeratedSetsClass of all
StandardTableauTupleswith an arbitraryleveland a fixedsize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: StandardTableauTuples(size=2).an_element() ([[1]], [[2]], [], []) sage: StandardTableauTuples(size=4).an_element() ([[1]], [[2, 3, 4]], [], [])
>>> 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)[source]¶
Bases:
StandardTableauTuplesClass 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: 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)
>>> 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)[source]¶
Bases:
StandardTableaux_residueAll standard tableau tuples with a fixed residue and shape.
INPUT:
shape– the shape of the partitions or partition tuplesresidue– the residue sequence of the label
EXAMPLES:
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]])]
>>> 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()[source]¶
Return a particular element of
self.EXAMPLES:
sage: T = StandardTableau([[1,3],[2]]).residue_sequence(3).standard_tableaux([2,1]) sage: T.an_element() [[1, 3], [2]]
>>> 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)[source]¶
Bases:
CombinatorialElementA class to model a tuple of tableaux.
INPUT:
t– list or tuple ofTableau, a list or tuple of lists of lists
OUTPUT: the Tableau tuple object constructed from
tA
TableauTupleis a tuple of tableau of shape aPartitionTuple. 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
TableauTuplelooks and behaves like a real tuple of (level 1)Tableaux. Many of the operations which are defined onTableauextend toTableauTuples. Tableau tuples of level 1 are just ordinaryTableau.In sage, the entries of
Tableauxcan 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 toTableauTupleas a tuple of tableaux thenTableauTuplereturns the corresponding tuple. Given a 1-tuple of tableaux the tableau itself is returned.EXAMPLES:
sage: t = TableauTuple([ [[6,9,10],[11]], [[1,2,3],[4,5]], [[7],[8]] ]); t ([[6, 9, 10], [11]], [[1, 2, 3], [4, 5]], [[7], [8]]) sage: t.level() 3 sage: t.size() 11 sage: t.shape() ([3, 1], [3, 2], [1, 1]) sage: t.is_standard() True sage: t.pp() # pretty 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
>>> 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
- add_entry(cell, m)[source]¶
Set the entry in
cellequal tom. If the cell does not exist then extend the tableau, otherwise just replace the entry.EXAMPLES:
sage: s = StandardTableauTuple([ [[3,4,7],[6,8]], [[9,13],[12]], [[1,5],[2,11],[10]] ]); s.pp() 3 4 7 9 13 1 5 6 8 12 2 11 10 sage: t = s.add_entry( (0,0,3),14); t.pp(); t.category() 3 4 7 14 9 13 1 5 6 8 12 2 11 10 Category of elements of Standard tableau tuples sage: t = s.add_entry( (0,0,3),15); t.pp(); t.category() 3 4 7 15 9 13 1 5 6 8 12 2 11 10 Category of elements of Tableau tuples sage: t = s.add_entry( (1,1,1),14); t.pp(); t.category() 3 4 7 9 13 1 5 6 8 12 14 2 11 10 Category of elements of Standard tableau tuples sage: t = s.add_entry( (2,1,1),14); t.pp(); t.category() 3 4 7 9 13 1 5 6 8 12 2 14 10 Category of elements of Tableau tuples sage: t = s.add_entry( (2,1,2),14); t.pp(); t.category() Traceback (most recent call last): ... IndexError: (2, 1, 2) is not an addable cell of the tableau
>>> 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)[source]¶
Return the list of cells in which the letter
mappears in the tableauself.The list is ordered with cells appearing from left to right.
EXAMPLES:
sage: t = TableauTuple([[[4,5]],[[1,1,2,4],[2,4,4],[4]],[[1,3,4],[3,4]]]) sage: t.cells_containing(4) [(0, 0, 0), (1, 2, 0), (1, 1, 1), (1, 1, 2), (1, 0, 3), (2, 1, 1), (2, 0, 2)] sage: t.cells_containing(6) []
>>> 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()[source]¶
Return the charge of the reading word of
self.See
charge()for more information.EXAMPLES:
sage: TableauTuple([[[4,5]],[[1,1,2,4],[2,4,4],[4]],[[1,3,4],[3,4]]]).charge() 4
>>> 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()[source]¶
Return the cocharge of the reading word of
self.See
cocharge()for more information.EXAMPLES:
sage: TableauTuple([[[4,5]],[[1,1,2,4],[2,4,4],[4]],[[1,3,4],[3,4]]]).charge() 4
>>> 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()[source]¶
Return the
PermutationGroupcorresponding toself. That is, return subgroup of the symmetric group of degreesize()which is the column stabilizer ofself.EXAMPLES:
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
>>> 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()[source]¶
Return a list of the components of tableau tuple
self.The \(components\) are the individual
Tableauwhich are contained in the tupleself.For compatibility with
TableauTuplesoflevel()1,components()should be used to iterate over the components ofTableauTuples.EXAMPLES:
sage: for t in TableauTuple([[1,2,3],[4,5]]).components(): t.pp() 1 2 3 4 5 sage: for t in TableauTuple([ [[1,2,3],[4,5]], [[6,7],[8,9]] ]).components(): t.pp() 1 2 3 4 5 6 7 8 9
>>> 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()[source]¶
Return the conjugate of the tableau tuple
self.The conjugate tableau tuple \(T'\) is the
TableauTupleobtained from \(T\) by reversing the order of the components and conjugating each component – that is, swapping the rows and columns of the all ofTableauin \(T\) (seesage.combinat.tableau.Tableau.conjugate()).EXAMPLES:
sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).conjugate() ([[9, 11, 12], [10]], [[5, 8], [6], [7]], [[1, 3], [2, 4]])
>>> 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)[source]¶
Return the content
kinself.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 thesize()ofself.EXAMPLES:
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(3,[0,0]) -1 sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(3,[0,1]) 0 sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(3,[0,2]) 1 sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).content(6,[0,2]) Traceback (most recent call last): ... ValueError: 6 must be contained in the tableaux
>>> 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()[source]¶
Return a sorted list of all entries of
self, in the order obtained by reading across the rows.EXAMPLES:
sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).entries() [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] sage: TableauTuple([[[1,2],[3,4]],[[9,10],[11],[12]],[[5,6,7],[8]]]).entries() [1, 2, 3, 4, 9, 10, 11, 12, 5, 6, 7, 8]
>>> 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)[source]¶
Return the entry of the cell
(l, r, c)inself.A cell is a tuple
(l, r, c)of coordinates, wherelis the component index,ris the row index, andcis the column index.EXAMPLES:
sage: t = TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]) sage: t.entry(1, 0, 0) 5 sage: t.entry(1, 1, 1) Traceback (most recent call last): ... IndexError: tuple index out of range
>>> 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()[source]¶
Return the first cell of
selfis 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
Noneis returned - in this case the tableau is column strict.OUTPUT:
The cell corresponding to the first column descent or
Noneif the tableau is column strict.EXAMPLES:
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
>>> 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()[source]¶
Return the first cell of
selfthat 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
Noneis returned - in this case the tableau is row strict.OUTPUT:
The cell corresponding to the first row descent or
Noneif the tableau is row strict.EXAMPLES:
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
>>> 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()[source]¶
Return
Trueif the tableauselfis column strict andFalseotherwise.A tableau tuple is column strict if the entries in each column of each component are in increasing order, when read from top to bottom.
EXAMPLES:
sage: TableauTuple([[[5,7],[8]],[[1, 3], [2, 4]],[[6]]]).is_column_strict() True sage: TableauTuple([[[1, 2], [2, 4]],[[4,5,6],[7,8]]]).is_column_strict() True sage: TableauTuple([[[1]],[[2, 3], [2, 4]]]).is_column_strict() False sage: TableauTuple([[[1]],[[2, 2], [4,5]]]).is_column_strict() True sage: TableauTuple([[[1,2],[6,7]],[[4,8], [6, 9]],[]]).is_column_strict() True
>>> 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()[source]¶
Return
Trueif the tableauselfis row strict andFalseotherwise.A tableau tuple is row strict if the entries in each row of each component are in increasing order, when read from left to right.
EXAMPLES:
sage: TableauTuple([[[5,7],[8]],[[1, 3], [2, 4]],[[6]]]).is_row_strict() True sage: TableauTuple([[[1, 2], [2, 4]],[[4,5,6],[7,8]]]).is_row_strict() True sage: TableauTuple([[[1]],[[2, 3], [2, 4]]]).is_row_strict() True sage: TableauTuple([[[1]],[[2, 2], [4,5]]]).is_row_strict() False sage: TableauTuple([[[1,2],[6,7]],[[4,8], [6, 9]],[]]).is_row_strict() True
>>> 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()[source]¶
Return
Trueif the tableauselfis a standard tableau andFalseotherwise.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 ofself.EXAMPLES:
sage: TableauTuple([[[5,7],[8]],[[1, 3], [2, 4]],[[6]]]).is_standard() True sage: TableauTuple([[[1, 2], [2, 4]],[[4,5,6],[7,8]]]).is_standard() False sage: TableauTuple([[[1]],[[2, 3], [2, 4]]]).is_standard() False sage: TableauTuple([[[1]],[[2, 2], [4,5]]]).is_row_strict() False sage: TableauTuple([[[1,2],[6,7]],[[4,8], [6, 9]],[]]).is_standard() False
>>> 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()[source]¶
Return the level of the tableau
self.This is just the number of components in the tableau tuple
self.EXAMPLES:
sage: TableauTuple([[[7,8,9]],[],[[1,2,3],[4,5],[6]]]).level() 3
>>> 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()[source]¶
Pretty printing for the tableau tuple
self.EXAMPLES:
sage: TableauTuple([ [[1,2,3],[4,5]], [[1,2,3],[4,5]] ]).pp() 1 2 3 1 2 3 4 5 4 5 sage: TableauTuple([ [[1,2],[3],[4]],[],[[6,7,8],[10,11],[12],[13]]]).pp() 1 2 - 6 7 8 3 10 11 4 12 13 sage: t = TableauTuple([ [[1,2,3],[4,5],[6],[9]], [[1,2,3],[4,5,8]], [[11,12,13],[14]] ]) sage: t.pp() 1 2 3 1 2 3 11 12 13 4 5 4 5 8 14 6 9 sage: TableauTuples.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()
>>> 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()[source]¶
Return the lexicographically minimal reduced expression for the permutation that maps the
initial_column_tableau()toself.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: 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]
>>> 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()[source]¶
Return the lexicographically minimal reduced expression for the permutation that maps the
initial_tableau()toself.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: 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]
>>> 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)[source]¶
Return the residue of the integer
kin the tableauself.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 thesize()ofself.OUTPUT: the residue of
kin a standard tableau. That is,EXAMPLES:
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
>>> 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)[source]¶
Return the restriction of the standard tableau
selftom.The restriction is the subtableau of
selfwhose entries are less than or equal tom.By default,
mis one less than the current size.EXAMPLES:
sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict() ([], [[1, 2], [3, 4]]) sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(6) ([[5]], [[1, 2], [3, 4]]) sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(5) ([[5]], [[1, 2], [3, 4]]) sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(4) ([], [[1, 2], [3, 4]]) sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(3) ([], [[1, 2], [3]]) sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(2) ([], [[1, 2]]) sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(1) ([], [[1]]) sage: TableauTuple([[[5]],[[1,2],[3,4]]]).restrict(0) ([], [])
>>> 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: 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
>>> 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()[source]¶
Return the
PermutationGroupcorresponding toself. That is, return subgroup of the symmetric group of degreesize()which is the row stabilizer ofself.EXAMPLES:
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]
>>> 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()[source]¶
Return the
PartitionTuplewhich is the shape of the tableau tupleself.EXAMPLES:
sage: TableauTuple([[[7,8,9]],[],[[1,2,3],[4,5],[6]]]).shape() ([3], [], [3, 2, 1])
>>> 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()[source]¶
Return the size of the tableau tuple
self.This is just the number of boxes, or the size, of the underlying
PartitionTuple.EXAMPLES:
sage: TableauTuple([[[7,8,9]],[],[[1,2,3],[4,5],[6]]]).size() 9
>>> 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)[source]¶
Return the action of a permutation
wonself.Consider a standard tableau tuple \(T = (t^{(1)}, t^{(2)}, \ldots t^{(l)})\) of size \(n\), then the action of \(w \in S_n\) is defined by permuting the entries of \(T\) (recall they are \(1, 2, \ldots, n\)). In particular, suppose the entry at cell \((k, i, j)\) is \(a\), then the entry becomes \(w(a)\). In general, the resulting tableau tuple \(wT\) may not be standard.
INPUT:
w– a permutation
EXAMPLES:
sage: TableauTuple([[[1,2],[4]],[[3,5]]]).symmetric_group_action_on_entries( Permutation(((4,5))) ) ([[1, 2], [5]], [[3, 4]]) sage: TableauTuple([[[1,2],[4]],[[3,5]]]).symmetric_group_action_on_entries( Permutation(((1,2))) ) ([[2, 1], [4]], [[3, 5]])
>>> 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()[source]¶
Return the list representation of the tableaux tuple
self.EXAMPLES:
sage: TableauTuple([ [[1,2,3],[4,5]], [[6,7],[8,9]] ]).to_list() [[[1, 2, 3], [4, 5]], [[6, 7], [8, 9]]]
>>> 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()[source]¶
Return a permutation with the entries in the tableau tuple
self.The permutation is obtained from
selfby reading the entries of the tableau tuple in order from left to right along the rows, and then top to bottom, in each component and then left to right along the components.EXAMPLES:
sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_permutation() [12, 11, 9, 10, 8, 5, 6, 7, 3, 4, 1, 2]
>>> 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()[source]¶
Return a word obtained from a row reading of the tableau tuple
self.EXAMPLES:
sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_word_by_row() word: 12,11,9,10,8,5,6,7,3,4,1,2
>>> 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
- to_word_by_column()[source]¶
Return the word obtained from a column reading of the tableau tuple
self.EXAMPLES:
sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_word_by_column() word: 12,11,9,10,8,5,6,7,3,1,4,2
>>> 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()[source]¶
Return a word obtained from a row reading of the tableau tuple
self.EXAMPLES:
sage: TableauTuple([[[1,2],[3,4]],[[5,6,7],[8]],[[9,10],[11],[12]]]).to_word_by_row() word: 12,11,9,10,8,5,6,7,3,4,1,2
>>> 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)[source]¶
An iterator for all the
TableauTuplethat can be obtained fromselfby adding a cell with the labeln. Ifnis not specified then a cell with labelnwill be added to the tableau tuple, wheren-1is the size of the tableau tuple before any cells are added.EXAMPLES:
sage: list(TableauTuple([[[1,2]],[[3]]]).up()) [([[1, 2, 4]], [[3]]), ([[1, 2], [4]], [[3]]), ([[1, 2]], [[3, 4]]), ([[1, 2]], [[3], [4]])]
>>> 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[source]¶
Bases:
UniqueRepresentation,ParentA factory class for the various classes of tableau tuples.
INPUT:
There are three optional arguments:
shape– determines aPartitionTuplewhich gives the shape of theTableauTupleslevel– 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
leveland the second thesizeof 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
TableauTuplesis possible.EXAMPLES:
sage: T3 = TableauTuples(3); T3 Tableau tuples of level 3 sage: [['a','b']] in TableauTuples() True sage: [['a','b']] in TableauTuples(level=3) False sage: t = TableauTuples(level=3)([[],[[1,1,1]],[]]); t ([], [[1, 1, 1]], []) sage: t in T3 True sage: t in TableauTuples() True sage: t in TableauTuples(size=3) True sage: t in TableauTuples(size=4) False sage: t in StandardTableauTuples() False sage: t.parent() Tableau tuples of level 3 sage: t.category() Category of elements of Tableau tuples of level 3
>>> 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
- Element[source]¶
alias of
TableauTuple
- level()[source]¶
Return the
levelof a tableau tuple inself, orNoneif different tableau tuples inselfcan have different sizes. Thelevelof a tableau tuple is just the level of the underlyingPartitionTuple.EXAMPLES:
sage: TableauTuples().level() is None True sage: TableauTuples(7).level() 7
>>> from sage.all import * >>> TableauTuples().level() is None True >>> TableauTuples(Integer(7)).level() 7
- level_one_parent_class[source]¶
alias of
Tableaux_all
- list()[source]¶
If the set of tableau tuples
selfis finite then this function returns the list of these tableau tuples. If the class is infinite an error is returned.EXAMPLES:
sage: StandardTableauTuples([[2,1],[2]]).list() [([[1, 2], [3]], [[4, 5]]), ([[1, 3], [2]], [[4, 5]]), ([[1, 2], [4]], [[3, 5]]), ([[1, 3], [4]], [[2, 5]]), ([[2, 3], [4]], [[1, 5]]), ([[1, 4], [2]], [[3, 5]]), ([[1, 4], [3]], [[2, 5]]), ([[2, 4], [3]], [[1, 5]]), ([[1, 2], [5]], [[3, 4]]), ([[1, 3], [5]], [[2, 4]]), ([[2, 3], [5]], [[1, 4]]), ([[1, 4], [5]], [[2, 3]]), ([[2, 4], [5]], [[1, 3]]), ([[3, 4], [5]], [[1, 2]]), ([[1, 5], [2]], [[3, 4]]), ([[1, 5], [3]], [[2, 4]]), ([[2, 5], [3]], [[1, 4]]), ([[1, 5], [4]], [[2, 3]]), ([[2, 5], [4]], [[1, 3]]), ([[3, 5], [4]], [[1, 2]])]
>>> 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[source]¶
- size()[source]¶
Return the
sizeof a tableau tuple inself, orNoneif different tableau tuples inselfcan have different sizes. Thesizeof a tableau tuple is just the size of the underlyingPartitionTuple.EXAMPLES:
sage: TableauTuples(size=14).size() 14
>>> from sage.all import * >>> TableauTuples(size=Integer(14)).size() 14
- class sage.combinat.tableau_tuple.TableauTuples_all[source]¶
Bases:
TableauTuplesThe parent class of all
TableauTuples, with arbitrarylevelandsize.
- class sage.combinat.tableau_tuple.TableauTuples_level(level)[source]¶
Bases:
TableauTuplesClass of all
TableauTupleswith a fixedleveland arbitrarysize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: TableauTuples(3).an_element() ([], [], []) sage: TableauTuples(5).an_element() ([], [], [], [], []) sage: T = TableauTuples(0) Traceback (most recent call last): ... ValueError: the level must be a positive integer
>>> 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)[source]¶
Bases:
TableauTuplesClass of all
TableauTupleswith a fixedleveland a fixedsize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: TableauTuples(3,0).an_element() ([], [], []) sage: TableauTuples(3,1).an_element() ([[1]], [], []) sage: TableauTuples(3,2).an_element() ([[1, 2]], [], [])
>>> 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)[source]¶
Bases:
TableauTuplesClass of all
TableauTupleswith a arbitraryleveland fixedsize.- an_element()[source]¶
Return a particular element of the class.
EXAMPLES:
sage: TableauTuples(size=3).an_element() ([], [[1, 2, 3]], []) sage: TableauTuples(size=0).an_element() ([], [], [])
>>> from sage.all import * >>> TableauTuples(size=Integer(3)).an_element() ([], [[1, 2, 3]], []) >>> TableauTuples(size=Integer(0)).an_element() ([], [], [])