Partition tuples¶

A PartitionTuple is a tuple of partitions. That is, an ordered \(k\)-tuple of partitions \(\mu=(\mu^{(1)},\mu^{(2)},...,\mu^{(k)})\). If

\[n = \lvert \mu \rvert = \lvert \mu^{(1)} \rvert + \lvert \mu^{(2)} \rvert + \cdots + \lvert \mu^{(k)} \rvert\]

then we say that \(\mu\) is a \(k\)-partition of \(n\).

In representation theory partition tuples arise as the natural indexing set for the ordinary irreducible representations of:

the wreath products of cyclic groups with symmetric groups,
the Ariki-Koike algebras, or the cyclotomic Hecke algebras of the complex reflection groups of type \(G(r,1,n)\),
the degenerate cyclotomic Hecke algebras of type \(G(r,1,n)\).

When these algebras are not semisimple, partition tuples index an important class of modules for the algebras, which are generalisations of the Specht modules of the symmetric groups.

Tuples of partitions also index the standard basis of the higher level combinatorial Fock spaces. As a consequence, the combinatorics of partition tuples encapsulates the canonical bases of crystal graphs for the irreducible integrable highest weight modules of the (quantized) affine special linear groups and the (quantized) affine general linear groups. By the categorification theorems of Ariki, Varagnolo-Vasserot, Stroppel-Webster and others, in characteristic zero the degenerate and non-degenerate cyclotomic Hecke algebras, via their Khovanov-Lauda-Rouquier grading, categorify the canonical bases of the quantum affine special and general linear groups.

Partitions are naturally in bijection with 1-tuples of partitions. Most of the combinatorial operations defined on partitions extend to partition tuples in a meaningful way. For example, the semisimple branching rules for the Specht modules are described by adding and removing cells from partition tuples and the modular branching rules correspond to adding and removing good and cogood nodes, which is the underlying combinatorics for the associated crystal graphs.

A PartitionTuple belongs to PartitionTuples and its derived classes. PartitionTuples is the parent class for all partitions tuples. Four different classes of tuples of partitions are currently supported:

PartitionTuples(level=k,size=n) are \(k\)-tuple of partitions of \(n\).
PartitionTuples(level=k) are \(k\)-tuple of partitions.
PartitionTuples(size=n) are tuples of partitions of \(n\).
PartitionTuples() are tuples of partitions.

Note

As with Partitions, in sage the cells, or nodes, of partition tuples are 0-based. For example, the (lexicographically) first cell in any non-empty partition tuple is \([0,0,0]\).

EXAMPLES:

Sage

sage: PartitionTuple([[2,2],[1,1],[2]]).cells()
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 1, 0), (2, 0, 0), (2, 0, 1)]

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(1),Integer(1)],[Integer(2)]]).cells()
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 1, 0), (2, 0, 0), (2, 0, 1)]

Note

Many PartitionTuple methods take the individual coordinates \((k,r,c)\) as their arguments, here \(k\) is the component, \(r\) is the row index and \(c\) is the column index. If your coordinates are in the form (k,r,c) then use Python’s *-operator.

EXAMPLES:

Sage

sage: mu=PartitionTuple([[1,1],[2],[2,1]])
sage: [ mu.arm_length(*c) for c in mu.cells()]
[0, 0, 1, 0, 1, 0, 0]

Python

>>> from sage.all import *
>>> mu=PartitionTuple([[Integer(1),Integer(1)],[Integer(2)],[Integer(2),Integer(1)]])
>>> [ mu.arm_length(*c) for c in mu.cells()]
[0, 0, 1, 0, 1, 0, 0]

Warning

In sage, if mu is a partition tuple then mu[k] most naturally refers to the \(k\)-th component of mu, so we use the convention of the \((k,r,c)\)-th cell in a partition tuple refers to the cell in component \(k\), row \(r\), and column \(c\). In the literature, the cells of a partition 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.

REFERENCES:

AUTHORS:

Andrew Mathas (2012-06-01): Initial classes.

EXAMPLES:

First is a finite enumerated set and the remaining classes are infinite enumerated sets:

Sage

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

Python

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

One tuples of partitions are naturally in bijection with partitions and, as far as possible, partition tuples attempts to identify one tuples with partitions:

Sage

sage: Partition([4,3]) == PartitionTuple([[4,3]])
True
sage: Partition([4,3]) == PartitionTuple([4,3])
True
sage: PartitionTuple([4,3])
[4, 3]
sage: Partition([4,3]) in PartitionTuples()
True

Python

>>> from sage.all import *
>>> Partition([Integer(4),Integer(3)]) == PartitionTuple([[Integer(4),Integer(3)]])
True
>>> Partition([Integer(4),Integer(3)]) == PartitionTuple([Integer(4),Integer(3)])
True
>>> PartitionTuple([Integer(4),Integer(3)])
[4, 3]
>>> Partition([Integer(4),Integer(3)]) in PartitionTuples()
True

Partition tuples come equipped with many of the corresponding methods for partitions. For example, it is possible to add and remove cells, to conjugate partition tuples, to work with their diagrams, compare partition tuples in dominance and so:

Sage

sage: PartitionTuple([[4,1],[],[2,2,1],[3]]).pp()
   ****   -   **   ***
   *          **
              *
sage: PartitionTuple([[4,1],[],[2,2,1],[3]]).conjugate()
([1, 1, 1], [3, 2], [], [2, 1, 1, 1])
sage: PartitionTuple([[4,1],[],[2,2,1],[3]]).conjugate().pp()
   *   ***   -   **
   *   **        *
   *             *
                 *
sage: lam = PartitionTuples(3)([[3,2],[],[1,1,1,1]]); lam
([3, 2], [], [1, 1, 1, 1])
sage: lam.level()
3
sage: lam.size()
9
sage: lam.category()
Category of elements of Partition tuples of level 3
sage: lam.parent()
Partition tuples of level 3
sage: lam[0]
[3, 2]
sage: lam[1]
[]
sage: lam[2]
[1, 1, 1, 1]
sage: lam.pp()
   ***   -   *
   **        *
             *
             *
sage: lam.removable_cells()
[(0, 0, 2), (0, 1, 1), (2, 3, 0)]
sage: lam.down_list()
[([2, 2], [], [1, 1, 1, 1]),
 ([3, 1], [], [1, 1, 1, 1]),
 ([3, 2], [], [1, 1, 1])]
sage: lam.addable_cells()
[(0, 0, 3), (0, 1, 2), (0, 2, 0), (1, 0, 0), (2, 0, 1), (2, 4, 0)]
sage: lam.up_list()
[([4, 2], [], [1, 1, 1, 1]),
 ([3, 3], [], [1, 1, 1, 1]),
 ([3, 2, 1], [], [1, 1, 1, 1]),
 ([3, 2], [1], [1, 1, 1, 1]),
 ([3, 2], [], [2, 1, 1, 1]),
 ([3, 2], [], [1, 1, 1, 1, 1])]
sage: lam.conjugate()
([4], [], [2, 2, 1])
sage: lam.dominates( PartitionTuple([[3],[1],[2,2,1]]) )
False
sage: lam.dominates( PartitionTuple([[3],[2],[1,1,1]]))
True

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(4),Integer(1)],[],[Integer(2),Integer(2),Integer(1)],[Integer(3)]]).pp()
   ****   -   **   ***
   *          **
              *
>>> PartitionTuple([[Integer(4),Integer(1)],[],[Integer(2),Integer(2),Integer(1)],[Integer(3)]]).conjugate()
([1, 1, 1], [3, 2], [], [2, 1, 1, 1])
>>> PartitionTuple([[Integer(4),Integer(1)],[],[Integer(2),Integer(2),Integer(1)],[Integer(3)]]).conjugate().pp()
   *   ***   -   **
   *   **        *
   *             *
                 *
>>> lam = PartitionTuples(Integer(3))([[Integer(3),Integer(2)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]]); lam
([3, 2], [], [1, 1, 1, 1])
>>> lam.level()
3
>>> lam.size()
9
>>> lam.category()
Category of elements of Partition tuples of level 3
>>> lam.parent()
Partition tuples of level 3
>>> lam[Integer(0)]
[3, 2]
>>> lam[Integer(1)]
[]
>>> lam[Integer(2)]
[1, 1, 1, 1]
>>> lam.pp()
   ***   -   *
   **        *
             *
             *
>>> lam.removable_cells()
[(0, 0, 2), (0, 1, 1), (2, 3, 0)]
>>> lam.down_list()
[([2, 2], [], [1, 1, 1, 1]),
 ([3, 1], [], [1, 1, 1, 1]),
 ([3, 2], [], [1, 1, 1])]
>>> lam.addable_cells()
[(0, 0, 3), (0, 1, 2), (0, 2, 0), (1, 0, 0), (2, 0, 1), (2, 4, 0)]
>>> lam.up_list()
[([4, 2], [], [1, 1, 1, 1]),
 ([3, 3], [], [1, 1, 1, 1]),
 ([3, 2, 1], [], [1, 1, 1, 1]),
 ([3, 2], [1], [1, 1, 1, 1]),
 ([3, 2], [], [2, 1, 1, 1]),
 ([3, 2], [], [1, 1, 1, 1, 1])]
>>> lam.conjugate()
([4], [], [2, 2, 1])
>>> lam.dominates( PartitionTuple([[Integer(3)],[Integer(1)],[Integer(2),Integer(2),Integer(1)]]) )
False
>>> lam.dominates( PartitionTuple([[Integer(3)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]))
True

Every partition tuple behaves every much like a tuple of partitions:

Sage

sage: mu = PartitionTuple([[4,1],[],[2,2,1],[3]])
sage: [ nu for nu in mu ]
[[4, 1], [], [2, 2, 1], [3]]
sage: Set([ type(nu) for nu in mu ])
{<class 'sage.combinat.partition.Partitions_all_with_category.element_class'>}
sage: mu[2][2]
1
sage: mu[3]
[3]
sage: mu.components()
[[4, 1], [], [2, 2, 1], [3]]
sage: mu.components() == [ nu for nu in mu ]
True
sage: mu[0]
[4, 1]
sage: mu[1]
[]
sage: mu[2]
[2, 2, 1]
sage: mu[2][0]
2
sage: mu[2][1]
2
sage: mu.level()
4
sage: len(mu)
4
sage: mu.cells()
[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 1, 0), (2, 0, 0), (2, 0, 1),
 (2, 1, 0), (2, 1, 1), (2, 2, 0), (3, 0, 0), (3, 0, 1), (3, 0, 2)]
sage: mu.addable_cells()
[(0, 0, 4), (0, 1, 1), (0, 2, 0), (1, 0, 0), (2, 0, 2), (2, 2, 1),
 (2, 3, 0), (3, 0, 3), (3, 1, 0)]
sage: mu.removable_cells()
[(0, 0, 3), (0, 1, 0), (2, 1, 1), (2, 2, 0), (3, 0, 2)]

Python

>>> from sage.all import *
>>> mu = PartitionTuple([[Integer(4),Integer(1)],[],[Integer(2),Integer(2),Integer(1)],[Integer(3)]])
>>> [ nu for nu in mu ]
[[4, 1], [], [2, 2, 1], [3]]
>>> Set([ type(nu) for nu in mu ])
{<class 'sage.combinat.partition.Partitions_all_with_category.element_class'>}
>>> mu[Integer(2)][Integer(2)]
1
>>> mu[Integer(3)]
[3]
>>> mu.components()
[[4, 1], [], [2, 2, 1], [3]]
>>> mu.components() == [ nu for nu in mu ]
True
>>> mu[Integer(0)]
[4, 1]
>>> mu[Integer(1)]
[]
>>> mu[Integer(2)]
[2, 2, 1]
>>> mu[Integer(2)][Integer(0)]
2
>>> mu[Integer(2)][Integer(1)]
2
>>> mu.level()
4
>>> len(mu)
4
>>> mu.cells()
[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 1, 0), (2, 0, 0), (2, 0, 1),
 (2, 1, 0), (2, 1, 1), (2, 2, 0), (3, 0, 0), (3, 0, 1), (3, 0, 2)]
>>> mu.addable_cells()
[(0, 0, 4), (0, 1, 1), (0, 2, 0), (1, 0, 0), (2, 0, 2), (2, 2, 1),
 (2, 3, 0), (3, 0, 3), (3, 1, 0)]
>>> mu.removable_cells()
[(0, 0, 3), (0, 1, 0), (2, 1, 1), (2, 2, 0), (3, 0, 2)]

Attached to a partition tuple is the corresponding Young, or parabolic, subgroup:

Sage

sage: mu.young_subgroup()                                                           # needs sage.groups
Permutation Group with generators
 [(), (12,13), (11,12), (8,9), (6,7), (3,4), (2,3), (1,2)]
sage: mu.young_subgroup_generators()                                                # needs sage.groups
[1, 2, 3, 6, 8, 11, 12]

Python

>>> from sage.all import *
>>> mu.young_subgroup()                                                           # needs sage.groups
Permutation Group with generators
 [(), (12,13), (11,12), (8,9), (6,7), (3,4), (2,3), (1,2)]
>>> mu.young_subgroup_generators()                                                # needs sage.groups
[1, 2, 3, 6, 8, 11, 12]

class sage.combinat.partition_tuple.PartitionTuple(parent, mu)[source]¶

Bases: CombinatorialElement

A tuple of Partition.

A tuple of partition comes equipped with many of methods available to partitions. The level of the PartitionTuple is the length of the tuple.

This is an ordered \(k\)-tuple of partitions \(\mu=(\mu^{(1)},\mu^{(2)},...,\mu^{(k)})\). If

\[n = \lvert \mu \rvert = \lvert \mu^{(1)} \rvert + \lvert \mu^{(2)} \rvert + \cdots + \lvert \mu^{(k)} \rvert\]

then \(\mu\) is a \(k\)-partition of \(n\).

In representation theory PartitionTuples arise as the natural indexing set for the ordinary irreducible representations of:

the wreath products of cyclic groups with symmetric groups
the Ariki-Koike algebras, or the cyclotomic Hecke algebras of the complex reflection groups of type \(G(r,1,n)\)
the degenerate cyclotomic Hecke algebras of type \(G(r,1,n)\)

When these algebras are not semisimple, partition tuples index an important class of modules for the algebras which are generalisations of the Specht modules of the symmetric groups.

Partitions are naturally in bijection with 1-tuples of partitions. Most of the combinatorial operations defined on partitions extend to PartitionTuples in a meaningful way. For example, the semisimple branching rules for the Specht modules are described by adding and removing cells from partition tuples and the modular branching rules correspond to adding and removing good and cogood nodes, which is the underlying combinatorics for the associated crystal graphs.

Warning

In the literature, the cells of a partition 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. In sage, if mu is a partition tuple then mu[k] most naturally refers to the \(k\)-th component of mu, so we use the convention of the \((k,r,c)\)-th cell in a partition tuple refers to the cell in component \(k\), row \(r\), and column \(c\).

INPUT:

Anything which can reasonably be interpreted as a tuple of partitions. That is, a list or tuple of partitions or valid input to Partition.

EXAMPLES:

Sage

sage: mu=PartitionTuple( [[3,2],[2,1],[],[1,1,1,1]] ); mu
([3, 2], [2, 1], [], [1, 1, 1, 1])
sage: nu=PartitionTuple( ([3,2],[2,1],[],[1,1,1,1]) ); nu
([3, 2], [2, 1], [], [1, 1, 1, 1])
sage: mu == nu
True
sage: mu is nu
False
sage: mu in PartitionTuples()
True
sage: mu.parent()
Partition tuples

sage: lam=PartitionTuples(3)([[3,2],[],[1,1,1,1]]); lam
([3, 2], [], [1, 1, 1, 1])
sage: lam.level()
3
sage: lam.size()
9
sage: lam.category()
Category of elements of Partition tuples of level 3
sage: lam.parent()
Partition tuples of level 3
sage: lam[0]
[3, 2]
sage: lam[1]
[]
sage: lam[2]
[1, 1, 1, 1]
sage: lam.pp()
   ***   -   *
   **        *
             *
             *
sage: lam.removable_cells()
[(0, 0, 2), (0, 1, 1), (2, 3, 0)]
sage: lam.down_list()
[([2, 2], [], [1, 1, 1, 1]), ([3, 1], [], [1, 1, 1, 1]), ([3, 2], [], [1, 1, 1])]
sage: lam.addable_cells()
[(0, 0, 3), (0, 1, 2), (0, 2, 0), (1, 0, 0), (2, 0, 1), (2, 4, 0)]
sage: lam.up_list()
[([4, 2], [], [1, 1, 1, 1]), ([3, 3], [], [1, 1, 1, 1]), ([3, 2, 1], [], [1, 1, 1, 1]), ([3, 2], [1], [1, 1, 1, 1]), ([3, 2], [], [2, 1, 1, 1]), ([3, 2], [], [1, 1, 1, 1, 1])]
sage: lam.conjugate()
([4], [], [2, 2, 1])
sage: lam.dominates( PartitionTuple([[3],[1],[2,2,1]]) )
False
sage: lam.dominates( PartitionTuple([[3],[2],[1,1,1]]))
True

Python

>>> from sage.all import *
>>> mu=PartitionTuple( [[Integer(3),Integer(2)],[Integer(2),Integer(1)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]] ); mu
([3, 2], [2, 1], [], [1, 1, 1, 1])
>>> nu=PartitionTuple( ([Integer(3),Integer(2)],[Integer(2),Integer(1)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]) ); nu
([3, 2], [2, 1], [], [1, 1, 1, 1])
>>> mu == nu
True
>>> mu is nu
False
>>> mu in PartitionTuples()
True
>>> mu.parent()
Partition tuples

>>> lam=PartitionTuples(Integer(3))([[Integer(3),Integer(2)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]]); lam
([3, 2], [], [1, 1, 1, 1])
>>> lam.level()
3
>>> lam.size()
9
>>> lam.category()
Category of elements of Partition tuples of level 3
>>> lam.parent()
Partition tuples of level 3
>>> lam[Integer(0)]
[3, 2]
>>> lam[Integer(1)]
[]
>>> lam[Integer(2)]
[1, 1, 1, 1]
>>> lam.pp()
   ***   -   *
   **        *
             *
             *
>>> lam.removable_cells()
[(0, 0, 2), (0, 1, 1), (2, 3, 0)]
>>> lam.down_list()
[([2, 2], [], [1, 1, 1, 1]), ([3, 1], [], [1, 1, 1, 1]), ([3, 2], [], [1, 1, 1])]
>>> lam.addable_cells()
[(0, 0, 3), (0, 1, 2), (0, 2, 0), (1, 0, 0), (2, 0, 1), (2, 4, 0)]
>>> lam.up_list()
[([4, 2], [], [1, 1, 1, 1]), ([3, 3], [], [1, 1, 1, 1]), ([3, 2, 1], [], [1, 1, 1, 1]), ([3, 2], [1], [1, 1, 1, 1]), ([3, 2], [], [2, 1, 1, 1]), ([3, 2], [], [1, 1, 1, 1, 1])]
>>> lam.conjugate()
([4], [], [2, 2, 1])
>>> lam.dominates( PartitionTuple([[Integer(3)],[Integer(1)],[Integer(2),Integer(2),Integer(1)]]) )
False
>>> lam.dominates( PartitionTuple([[Integer(3)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]))
True

See also

Element[source]¶: alias of Partition

add_cell(k, r, c)[source]¶

Return the partition tuple obtained by adding a cell in row r, column c, and component k.

This does not change self.

EXAMPLES:

Sage

sage: PartitionTuple([[1,1],[4,3],[2,1,1]]).add_cell(0,0,1)
([2, 1], [4, 3], [2, 1, 1])

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(1),Integer(1)],[Integer(4),Integer(3)],[Integer(2),Integer(1),Integer(1)]]).add_cell(Integer(0),Integer(0),Integer(1))
([2, 1], [4, 3], [2, 1, 1])

addable_cells()[source]¶

Return a list of the removable cells of this partition tuple.

All indices are of the form (k, r, c), where r is the row-index, c is the column index and k is the component.

EXAMPLES:

Sage

sage: PartitionTuple([[1,1],[2],[2,1]]).addable_cells()
[(0, 0, 1), (0, 2, 0), (1, 0, 2), (1, 1, 0), (2, 0, 2), (2, 1, 1), (2, 2, 0)]
sage: PartitionTuple([[1,1],[4,3],[2,1,1]]).addable_cells()
[(0, 0, 1), (0, 2, 0), (1, 0, 4), (1, 1, 3), (1, 2, 0), (2, 0, 2), (2, 1, 1), (2, 3, 0)]

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(1),Integer(1)],[Integer(2)],[Integer(2),Integer(1)]]).addable_cells()
[(0, 0, 1), (0, 2, 0), (1, 0, 2), (1, 1, 0), (2, 0, 2), (2, 1, 1), (2, 2, 0)]
>>> PartitionTuple([[Integer(1),Integer(1)],[Integer(4),Integer(3)],[Integer(2),Integer(1),Integer(1)]]).addable_cells()
[(0, 0, 1), (0, 2, 0), (1, 0, 4), (1, 1, 3), (1, 2, 0), (2, 0, 2), (2, 1, 1), (2, 3, 0)]

arm_length(k, r, c)[source]¶

Return the length of the arm of cell (k, r, c) in self.

INPUT:

k – the component
r – the row
c – the cell

OUTPUT: the arm length as an integer

The arm of cell (k, r, c) is the number of cells in the k-th component which are to the right of the cell in row r and column c.

EXAMPLES:

Sage

sage: PartitionTuple([[],[2,1],[2,2,1],[3]]).arm_length(2,0,0)
1
sage: PartitionTuple([[],[2,1],[2,2,1],[3]]).arm_length(2,0,1)
0
sage: PartitionTuple([[],[2,1],[2,2,1],[3]]).arm_length(2,2,0)
0

Python

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

block(e, multicharge)[source]¶

Return a dictionary \(\beta\) that determines the block associated to the partition self and the quantum_characteristic() e.

INPUT:

e – the quantum characteristic
multicharge – the multicharge (default: \((0,)\))

OUTPUT:

a dictionary giving the multiplicities of the residues in the partition tuple self

In more detail, the value beta[i] is equal to the number of nodes of residue i. This corresponds to the positive root

\[\sum_{i\in I} \beta_i \alpha_i \in Q^+,\]

a element of the positive root lattice of the corresponding Kac-Moody algebra. See [DJM1998] and [BK2009] for more details.

This is a useful statistics because two Specht modules for a cyclotomic Hecke algebra of type \(A\) belong to the same block if and only if they correspond to same element \(\beta\) of the root lattice, given above.

We return a dictionary because when the quantum characteristic is \(0\), the Cartan type is \(A_{\infty}\), in which case the simple roots are indexed by the integers.

EXAMPLES:

Sage

sage: PartitionTuple([[2,2],[2,2]]).block(0,(0,0))
{-1: 2, 0: 4, 1: 2}
sage: PartitionTuple([[2,2],[2,2]]).block(2,(0,0))
{0: 4, 1: 4}
sage: PartitionTuple([[2,2],[2,2]]).block(2,(0,1))
{0: 4, 1: 4}
sage: PartitionTuple([[2,2],[2,2]]).block(3,(0,2))
{0: 3, 1: 2, 2: 3}
sage: PartitionTuple([[2,2],[2,2]]).block(3,(0,2))
{0: 3, 1: 2, 2: 3}
sage: PartitionTuple([[2,2],[2,2]]).block(3,(3,2))
{0: 3, 1: 2, 2: 3}
sage: PartitionTuple([[2,2],[2,2]]).block(4,(0,0))
{0: 4, 1: 2, 3: 2}

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).block(Integer(0),(Integer(0),Integer(0)))
{-1: 2, 0: 4, 1: 2}
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).block(Integer(2),(Integer(0),Integer(0)))
{0: 4, 1: 4}
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).block(Integer(2),(Integer(0),Integer(1)))
{0: 4, 1: 4}
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).block(Integer(3),(Integer(0),Integer(2)))
{0: 3, 1: 2, 2: 3}
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).block(Integer(3),(Integer(0),Integer(2)))
{0: 3, 1: 2, 2: 3}
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).block(Integer(3),(Integer(3),Integer(2)))
{0: 3, 1: 2, 2: 3}
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).block(Integer(4),(Integer(0),Integer(0)))
{0: 4, 1: 2, 3: 2}

cells()[source]¶

Return the coordinates of the cells of self. Coordinates are given as (component index, row index, column index) and are 0 based.

EXAMPLES:

Sage

sage: PartitionTuple([[2,1],[1],[1,1,1]]).cells()
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 0, 0), (2, 1, 0), (2, 2, 0)]

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(1)],[Integer(1),Integer(1),Integer(1)]]).cells()
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 0, 0), (2, 1, 0), (2, 2, 0)]

components()[source]¶

Return a list containing the shape of this partition.

This function exists in order to give a uniform way of iterating over the "components" of partition tuples of level 1 (partitions) and for higher levels.

EXAMPLES:

Sage

sage: for t in PartitionTuple([[2,1],[3,2],[3]]).components():
....:     print('%s\n' % t.ferrers_diagram())
**
*

***
**

***

sage: for t in PartitionTuple([3,2]).components():
....:     print('%s\n' % t.ferrers_diagram())
***
**

Python

>>> from sage.all import *
>>> for t in PartitionTuple([[Integer(2),Integer(1)],[Integer(3),Integer(2)],[Integer(3)]]).components():
...     print('%s\n' % t.ferrers_diagram())
**
*
<BLANKLINE>
***
**
<BLANKLINE>
***
<BLANKLINE>
>>> for t in PartitionTuple([Integer(3),Integer(2)]).components():
...     print('%s\n' % t.ferrers_diagram())
***
**

conjugate()[source]¶

Return the conjugate partition tuple of self.

The conjugate partition tuple is obtained by reversing the order of the components and then swapping the rows and columns in each component.

EXAMPLES:

Sage

sage: PartitionTuple([[2,1],[1],[1,1,1]]).conjugate()
([3], [1], [2, 1])

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(1)],[Integer(1),Integer(1),Integer(1)]]).conjugate()
([3], [1], [2, 1])

contains(mu)[source]¶

Return True if this partition tuple contains \(\mu\).

If \(\lambda=(\lambda^{(1)}, \ldots, \lambda^{(l)})\) and \(\mu=(\mu^{(1)}, \ldots, \mu^{(m)})\) are two partition tuples then \(\lambda\) contains \(\mu\) if \(m \leq l\) and \(\mu^{(i)}_r \leq \lambda^{(i)}_r\) for \(1 \leq i \leq m\) and \(r \geq 0\).

EXAMPLES:

Sage

sage: PartitionTuple([[1,1],[2],[2,1]]).contains( PartitionTuple([[1,1],[2],[2,1]]) )
True

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(1),Integer(1)],[Integer(2)],[Integer(2),Integer(1)]]).contains( PartitionTuple([[Integer(1),Integer(1)],[Integer(2)],[Integer(2),Integer(1)]]) )
True

content(k, r, c, multicharge)[source]¶

Return the content of the cell.

Let \(m_k =\) multicharge[k], then the content of a cell is \(m_k + c - r\).

If the multicharge is a list of integers then it simply offsets the values of the contents in each component. On the other hand, if the multicharge belongs to \(\ZZ/e\ZZ\) then the corresponding \(e\)-residue is returned (that is, the content mod \(e\)).

As with the content method for partitions, the content of a cell does not technically depend on the partition tuple, but this method is included because it is often useful.

EXAMPLES:

Sage

sage: PartitionTuple([[2,1],[2],[1,1,1]]).content(0,1,0, [0,0,0])
-1
sage: PartitionTuple([[2,1],[2],[1,1,1]]).content(0,1,0, [1,0,0])
0
sage: PartitionTuple([[2,1],[2],[1,1,1]]).content(2,1,0, [0,0,0])
-1

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]).content(Integer(0),Integer(1),Integer(0), [Integer(0),Integer(0),Integer(0)])
-1
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]).content(Integer(0),Integer(1),Integer(0), [Integer(1),Integer(0),Integer(0)])
0
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]).content(Integer(2),Integer(1),Integer(0), [Integer(0),Integer(0),Integer(0)])
-1

and now we return the 3-residue of a cell:

Sage

sage: multicharge = [IntegerModRing(3)(c) for c in [0,0,0]]
sage: PartitionTuple([[2,1],[2],[1,1,1]]).content(0,1,0, multicharge)
2

Python

>>> from sage.all import *
>>> multicharge = [IntegerModRing(Integer(3))(c) for c in [Integer(0),Integer(0),Integer(0)]]
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]).content(Integer(0),Integer(1),Integer(0), multicharge)
2

content_tableau(multicharge)[source]¶

Return the tableau which has (k,r,c)th entry equal to the content multicharge[k]-r+c of this cell.

As with the content function, by setting the multicharge appropriately the tableau containing the residues is returned.

EXAMPLES:

Sage

sage: PartitionTuple([[2,1],[2],[1,1,1]]).content_tableau([0,0,0])
([[0, 1], [-1]], [[0, 1]], [[0], [-1], [-2]])
sage: PartitionTuple([[2,1],[2],[1,1,1]]).content_tableau([0,0,1]).pp()
    0  1     0  1     1
   -1                 0
                     -1

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]).content_tableau([Integer(0),Integer(0),Integer(0)])
([[0, 1], [-1]], [[0, 1]], [[0], [-1], [-2]])
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]).content_tableau([Integer(0),Integer(0),Integer(1)]).pp()
    0  1     0  1     1
   -1                 0
                     -1

as with the content function the multicharge can be used to return the tableau containing the residues of the cells:

Sage

sage: multicharge=[ IntegerModRing(3)(c) for c in [0,0,1] ]
sage: PartitionTuple([[2,1],[2],[1,1,1]]).content_tableau(multicharge).pp()
    0  1     0  1     1
    2                 0
                      2

Python

>>> from sage.all import *
>>> multicharge=[ IntegerModRing(Integer(3))(c) for c in [Integer(0),Integer(0),Integer(1)] ]
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2)],[Integer(1),Integer(1),Integer(1)]]).content_tableau(multicharge).pp()
    0  1     0  1     1
    2                 0
                      2

corners()[source]¶

Return a list of the removable cells of this partition tuple.

All indices are of the form (k, r, c), where r is the row-index, c is the column index and k is the component.

EXAMPLES:

Sage

sage: PartitionTuple([[1,1],[2],[2,1]]).removable_cells()
[(0, 1, 0), (1, 0, 1), (2, 0, 1), (2, 1, 0)]
sage: PartitionTuple([[1,1],[4,3],[2,1,1]]).removable_cells()
[(0, 1, 0), (1, 0, 3), (1, 1, 2), (2, 0, 1), (2, 2, 0)]

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(1),Integer(1)],[Integer(2)],[Integer(2),Integer(1)]]).removable_cells()
[(0, 1, 0), (1, 0, 1), (2, 0, 1), (2, 1, 0)]
>>> PartitionTuple([[Integer(1),Integer(1)],[Integer(4),Integer(3)],[Integer(2),Integer(1),Integer(1)]]).removable_cells()
[(0, 1, 0), (1, 0, 3), (1, 1, 2), (2, 0, 1), (2, 2, 0)]

defect(e, multicharge)[source]¶

Return the e-defect or the e-weight self.

The \(e\)-defect is the number of (connected) \(e\)-rim hooks that can be removed from the partition.

The defect of a partition tuple is given by

\[\text{defect}(\beta) = (\Lambda, \beta) - \tfrac12(\beta, \beta),\]

where \(\Lambda = \sum_r \Lambda_{\kappa_r}\) for the multicharge \((\kappa_1, \ldots, \kappa_{\ell})\) and \(\beta = \sum_{(r,c)} \alpha_{(c-r) \pmod e}\), with the sum being over the cells in the partition.

INPUT:

e – the quantum characteristic
multicharge – the multicharge (default: \((0,)\))

OUTPUT: a nonnegative integer, which is the defect of the block containing the partition tuple self

EXAMPLES:

Sage

sage: PartitionTuple([[2,2],[2,2]]).defect(0,(0,0))
0
sage: PartitionTuple([[2,2],[2,2]]).defect(2,(0,0))
8
sage: PartitionTuple([[2,2],[2,2]]).defect(2,(0,1))
8
sage: PartitionTuple([[2,2],[2,2]]).defect(3,(0,2))
5
sage: PartitionTuple([[2,2],[2,2]]).defect(3,(0,2))
5
sage: PartitionTuple([[2,2],[2,2]]).defect(3,(3,2))
2
sage: PartitionTuple([[2,2],[2,2]]).defect(4,(0,0))
0

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).defect(Integer(0),(Integer(0),Integer(0)))
0
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).defect(Integer(2),(Integer(0),Integer(0)))
8
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).defect(Integer(2),(Integer(0),Integer(1)))
8
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).defect(Integer(3),(Integer(0),Integer(2)))
5
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).defect(Integer(3),(Integer(0),Integer(2)))
5
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).defect(Integer(3),(Integer(3),Integer(2)))
2
>>> PartitionTuple([[Integer(2),Integer(2)],[Integer(2),Integer(2)]]).defect(Integer(4),(Integer(0),Integer(0)))
0

degree(e)[source]¶

Return the e-th degree of self.

The \(e\)-th degree is the sum of the degrees of the standard tableaux of shape \(\lambda\). The \(e\)-th degree is the exponent of \(\Phi_e(q)\) in the Gram determinant of the Specht module for a semisimple cyclotomic Hecke algebra of type \(A\) with parameter \(q\).

For this calculation the multicharge \((\kappa_1, \ldots, \kappa_l)\) is chosen so that \(\kappa_{r+1} - \kappa_r > n\), where \(n\) is the size() of \(\lambda\) as this ensures that the Hecke algebra is semisimple.

INPUT:

e – integer \(e > 1\)

OUTPUT: nonnegative integer

EXAMPLES:

Sage

sage: PartitionTuple([[2,1],[2,2]]).degree(2)
532
sage: PartitionTuple([[2,1],[2,2]]).degree(3)
259
sage: PartitionTuple([[2,1],[2,2]]).degree(4)
196
sage: PartitionTuple([[2,1],[2,2]]).degree(5)
105
sage: PartitionTuple([[2,1],[2,2]]).degree(6)
105
sage: PartitionTuple([[2,1],[2,2]]).degree(7)
0

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2),Integer(2)]]).degree(Integer(2))
532
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2),Integer(2)]]).degree(Integer(3))
259
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2),Integer(2)]]).degree(Integer(4))
196
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2),Integer(2)]]).degree(Integer(5))
105
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2),Integer(2)]]).degree(Integer(6))
105
>>> PartitionTuple([[Integer(2),Integer(1)],[Integer(2),Integer(2)]]).degree(Integer(7))
0

Therefore, the Gram determinant of \(S(2,1|2,2)\) when the Hecke parameter \(q\) is “generic” is

\[q^N \Phi_2(q)^{532}\Phi_3(q)^{259}\Phi_4(q)^{196}\Phi_5(q)^{105}\Phi_6(q)^{105}\]

for some integer \(N\). Compare with prime_degree().

diagram()[source]¶

Return a string for the Ferrers diagram of self.

EXAMPLES:

Sage

sage: print(PartitionTuple([[2,1],[3,2],[1,1,1]]).diagram())
   **   ***   *
   *    **    *
              *
sage: print(PartitionTuple([[3,2],[2,1],[],[1,1,1,1]]).diagram())
   ***   **   -   *
   **    *        *
                  *
                  *
sage: PartitionTuples.options(convention='french')
sage: print(PartitionTuple([[3,2],[2,1],[],[1,1,1,1]]).diagram())
                  *
                  *
   **    *        *
   ***   **   -   *
sage: PartitionTuples.options._reset()

Python

>>> from sage.all import *
>>> print(PartitionTuple([[Integer(2),Integer(1)],[Integer(3),Integer(2)],[Integer(1),Integer(1),Integer(1)]]).diagram())
   **   ***   *
   *    **    *
              *
>>> print(PartitionTuple([[Integer(3),Integer(2)],[Integer(2),Integer(1)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]]).diagram())
   ***   **   -   *
   **    *        *
                  *
                  *
>>> PartitionTuples.options(convention='french')
>>> print(PartitionTuple([[Integer(3),Integer(2)],[Integer(2),Integer(1)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]]).diagram())
                  *
                  *
   **    *        *
   ***   **   -   *
>>> PartitionTuples.options._reset()

dominates(mu)[source]¶

Return True if the PartitionTuple dominates or equals \(\mu\) and False otherwise.

Given partition tuples \(\mu=(\mu^{(1)},...,\mu^{(m)})\) and \(\nu=(\nu^{(1)},...,\nu^{(n)})\) then \(\mu\) dominates \(\nu\) if

\[\sum_{k=1}^{l-1} |\mu^{(k)}| +\sum_{r \geq 1} \mu^{(l)}_r \geq \sum_{k=1}^{l-1} |\nu^{(k)}| + \sum_{r \geq 1} \nu^{(l)}_r\]

EXAMPLES:

Sage

sage: mu=PartitionTuple([[1,1],[2],[2,1]])
sage: nu=PartitionTuple([[1,1],[1,1],[2,1]])
sage: mu.dominates(mu)
True
sage: mu.dominates(nu)
True
sage: nu.dominates(mu)
False
sage: tau=PartitionTuple([[],[2,1],[]])
sage: tau.dominates([[2,1],[],[]])
False
sage: tau.dominates([[],[],[2,1]])
True

Python

>>> from sage.all import *
>>> mu=PartitionTuple([[Integer(1),Integer(1)],[Integer(2)],[Integer(2),Integer(1)]])
>>> nu=PartitionTuple([[Integer(1),Integer(1)],[Integer(1),Integer(1)],[Integer(2),Integer(1)]])
>>> mu.dominates(mu)
True
>>> mu.dominates(nu)
True
>>> nu.dominates(mu)
False
>>> tau=PartitionTuple([[],[Integer(2),Integer(1)],[]])
>>> tau.dominates([[Integer(2),Integer(1)],[],[]])
False
>>> tau.dominates([[],[],[Integer(2),Integer(1)]])
True

down()[source]¶

Generator (iterator) for the partition tuples that are obtained from self by removing a cell.

EXAMPLES:

Sage

sage: [mu for mu in PartitionTuple([[],[3,1],[1,1]]).down()]
[([], [2, 1], [1, 1]), ([], [3], [1, 1]), ([], [3, 1], [1])]
sage: [mu for mu in PartitionTuple([[],[],[]]).down()]
[]

Python

>>> from sage.all import *
>>> [mu for mu in PartitionTuple([[],[Integer(3),Integer(1)],[Integer(1),Integer(1)]]).down()]
[([], [2, 1], [1, 1]), ([], [3], [1, 1]), ([], [3, 1], [1])]
>>> [mu for mu in PartitionTuple([[],[],[]]).down()]
[]

down_list()[source]¶

Return a list of the partition tuples that can be formed from self by removing a cell.

EXAMPLES:

Sage

sage: PartitionTuple([[],[3,1],[1,1]]).down_list()
[([], [2, 1], [1, 1]), ([], [3], [1, 1]), ([], [3, 1], [1])]
sage: PartitionTuple([[],[],[]]).down_list()
[]

Python

>>> from sage.all import *
>>> PartitionTuple([[],[Integer(3),Integer(1)],[Integer(1),Integer(1)]]).down_list()
[([], [2, 1], [1, 1]), ([], [3], [1, 1]), ([], [3, 1], [1])]
>>> PartitionTuple([[],[],[]]).down_list()
[]

ferrers_diagram()[source]¶

Return a string for the Ferrers diagram of self.

EXAMPLES:

Sage

sage: print(PartitionTuple([[2,1],[3,2],[1,1,1]]).diagram())
   **   ***   *
   *    **    *
              *
sage: print(PartitionTuple([[3,2],[2,1],[],[1,1,1,1]]).diagram())
   ***   **   -   *
   **    *        *
                  *
                  *
sage: PartitionTuples.options(convention='french')
sage: print(PartitionTuple([[3,2],[2,1],[],[1,1,1,1]]).diagram())
                  *
                  *
   **    *        *
   ***   **   -   *
sage: PartitionTuples.options._reset()

Python

>>> from sage.all import *
>>> print(PartitionTuple([[Integer(2),Integer(1)],[Integer(3),Integer(2)],[Integer(1),Integer(1),Integer(1)]]).diagram())
   **   ***   *
   *    **    *
              *
>>> print(PartitionTuple([[Integer(3),Integer(2)],[Integer(2),Integer(1)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]]).diagram())
   ***   **   -   *
   **    *        *
                  *
                  *
>>> PartitionTuples.options(convention='french')
>>> print(PartitionTuple([[Integer(3),Integer(2)],[Integer(2),Integer(1)],[],[Integer(1),Integer(1),Integer(1),Integer(1)]]).diagram())
                  *
                  *
   **    *        *
   ***   **   -   *
>>> PartitionTuples.options._reset()

garnir_tableau(*cell)[source]¶

Return the Garnir tableau of shape self corresponding to the cell cell.

If cell \(= (k,a,c)\) then \((k,a+1,c)\) must belong to the diagram of the PartitionTuple. If this is not the case then we return False.

Note

The function also sets g._garnir_cell equal to cell which is used by some other functions.

The Garnir tableaux play an important role in integral and non-semisimple representation theory because they determine the “straightening” rules for the Specht modules over an arbitrary ring.

The Garnir tableau are the “first” non-standard tableaux which arise when you act by simple transpositions. If \((k,a,c)\) is a cell in the Young diagram of a partition, which is not at the bottom of its column, then the corresponding Garnir tableau has the integers \(1, 2, \ldots, n\) entered in order from left to right along the rows of the diagram up to the cell \((k,a,c-1)\), then along the cells \((k,a+1,1)\) to \((k,a+1,c)\), then \((k,a,c)\) until the end of row \(a\) and then continuing from left to right in the remaining positions. The examples below probably make this clearer!

EXAMPLES:

Sage

sage: PartitionTuple([[5,3],[2,2],[4,3]]).garnir_tableau((0,0,2)).pp()
     1  2  6  7  8     9 10    13 14 15 16
     3  4  5          11 12    17 18 19
sage: PartitionTuple([[5,3,3],[2,2],[4,3]]).garnir_tableau((0,0,2)).pp()
     1  2  6  7  8    12 13    16 17 18 19
     3  4  5          14 15    20 21 22
     9 10 11
sage: PartitionTuple([[5,3,3],[2,2],[4,3]]).garnir_tableau((0,1,2)).pp()
     1  2  3  4  5    12 13    16 17 18 19
     6  7 11          14 15    20 21 22
     8  9 10
sage: PartitionTuple([[5,3,3],[2,2],[4,3]]).garnir_tableau((1,0,0)).pp()
     1  2  3  4  5    13 14    16 17 18 19
     6  7  8          12 15    20 21 22
     9 10 11
sage: PartitionTuple([[5,3,3],[2,2],[4,3]]).garnir_tableau((1,0,1)).pp()
     1  2  3  4  5    12 15    16 17 18 19
     6  7  8          13 14    20 21 22
     9 10 11
sage: PartitionTuple([[5,3,3],[2,2],[4,3]]).garnir_tableau((2,0,1)).pp()
     1  2  3  4  5    12 13    16 19 20 21
     6  7  8          14 15    17 18 22
     9 10 11
sage: PartitionTuple([[5,3,3],[2,2],[4,3]]).garnir_tableau((2,1,1)).pp()
Traceback (most recent call last):
...
ValueError: (comp, row+1, col) must be inside the diagram

Python

>>> from sage.all import *
>>> PartitionTuple([[Integer(5),Integer(3)],[Integer(2),Integer(2)],[Integer(4),Integer(3)]]).garnir_tableau((Integer(0),Integer(0),Integer(2))).pp()
     1  2  6  7  8     9 10    13 14 15 16
     3  4  5          11 12    17 18 19
>>> PartitionTuple([[Integer(5),Integer(3),Integer(3)],[Integer(2),Integer(2)],[Integer(4),Integer(3)]]).garnir_tableau((Integer(0),Integer(0),Integer(2))).pp()
     1  2  6  7  8    12 13    16 17 18 19
     3  4  5          14 15    20 21 22
     9 10 11
>>> PartitionTuple([[Integer(5),Integer(3),Integer(3)],[Integer(2),Integer(2)],[Integer(4),Integer(3)]]).garnir_tableau((Integer(0),Integer(1),Integer(2))).pp()
     1  2  3  4  5    12 13    16 17 18 19
     6  7 11          14 15    20 21 22
     8  9 10
>>> PartitionTuple([[Integer(5),Integer(3),Integer(3)],[Integer(2),Integer(2)],[Integer(4),Integer(3)]]).garnir_tableau((Integer(1),Integer(0),Integer(0))).pp()
     1  2  3  4  5    13 14    16 17 18 19
     6  7  8          12 15    20 21 22
     9 10 11
>>> PartitionTuple([[Integer(5),Integer(3),Integer(3)],[Integer(2),Integer(2)],[Integer(4),Integer(3)]]).garnir_tableau((Integer(1),Integer(0),Integer(1))).pp()
     1  2  3  4  5    12 15    16 17 18 19
     6  7  8          13 14    20 21 22
     9 10 11
>>> PartitionTuple([[Integer(5),Integer(3),Integer(3)],[Integer(2),Integer(2)],[Integer(4),Integer(3)]]).garnir_tableau((Integer(2),Integer(0),Integer(1))).pp()
     1  2  3  4  5    12 13    16 19 20 21
     6  7  8          14 15    17 18 22
     9 10 11
>>> PartitionTuple([[Integer(5),Integer(3),Integer(3)],[Integer(2),Integer(2)],[Integer(4),Integer(3)]]).garnir_tableau((Integer(2),Integer(1),Integer(1))).pp()
Traceback (most recent call last):
...
ValueError: (comp, row+1, col) must be inside the diagram