Coverage for local/lib/python2.7/site-packages/sage/combinat/tableau_tuple.py : 72%

r""" 

TableauTuples 

A :class:`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, :class:`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 :class:`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 :class:`TableauTuple`. 

A tableaux can be thought of as the labelled diagram of a partition. 

Analogously, a :class:`TableauTuple` is the labelled diagram of a 

:class:`PartitionTuple`. That is, a :class:`TableauTuple` is a tableau of 

:class:`PartitionTuple` shape. As much as possible, :class:`TableauTuples` 

behave in exactly the same way as :class:`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 

:class:`PartitionTuple` are ordered triples `(k, r, c)`, with `r` and `c` as 

before and `k` indexes the component. 

Frequently, we will call a :class:`TableauTuple` a tableau, or a tableau of 

:class:`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 :class:`PartitionTuples`. 

.. NOTE:: 

As with partitions and tableaux, the cells are 0-based. For example, the 

(lexicographically) first cell in any non-empty tableau tuple is 

``[0,0,0]``. 

EXAMPLES:: 

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

[[1, 2, 3], [4, 5]] 

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

([[6, 7], [8, 9]], [[1, 2, 3], [4, 5]]) 

sage: t.pp() 

6 7 1 2 3 

8 9 4 5 

sage: t(0,0,1) 

7 

sage: t(1,0,1) 

2 

sage: t.shape() 

([2, 2], [3, 2]) 

sage: t.size() 

9 

sage: t.level() 

2 

sage: t.components() 

[[[6, 7], [8, 9]], [[1, 2, 3], [4, 5]]] 

sage: t.entries() 

[6, 7, 8, 9, 1, 2, 3, 4, 5] 

sage: t.parent() 

Tableau tuples 

sage: t.category() 

Category of elements of Tableau tuples 

One reason for implementing :class:`TableauTuples` is to be able to consider 

:class:`StandardTableauTuples`. These objects arise in many areas of algebraic 

combinatorics. In particular, they index bases for the Specht modules of the