### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »

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

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: mu=PartitionTuple([[1,1],[2],[2,1]])
    sage: [ 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:

[DJM99] | R. Dipper, G. James and A. Mathas “The cyclotomic q-Schur algebra”, Math. Z, 229 (1999), 385-416.

[BK09] | J. Brundan and A. Kleshchev “Graded decomposition numbers for cyclotomic Hecke algebras”, Adv. Math., 222 (2009), 1883-1942”

AUTHORS:

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

EXAMPLES:

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

    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)[:]
    [([2], [], []),
     ([1, 1], [], []),
     ([1], [1], []),
     ([1], [], [1]),
     ([], [2], []),
     ([], [1, 1], []),
     ([], [1], [1]),
     ([], [], [2]),
     ([], [], [1, 1])]
    sage: PartitionTuples(2,3).list()
    [([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: 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

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

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

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

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

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

class `sage.combinat.partition_tuple.``PartitionTuple`(parent, mu)

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

  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.

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

  TESTS:

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

  See also

  - `PartitionTuples`
  - `Partitions`
  `Element`

    alias of `Partition`

  `add_cell`(k, r, c)

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

    This does not change `self`.

    EXAMPLES:

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

  `addable_cells`()

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

  `arm_length`(k, r, c)

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

    INPUT:

    - `k` – The compoenent
    - `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: 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

  `cells`()

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

    EXAMPLES:

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

  `components`()

    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.

    EXAMPLE:

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

  `conjugate`()

    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: PartitionTuple([[2,1],[1],[1,1,1]]).conjugate()
        ([3], [1], [2, 1])

  `contains`(mu)

    Returns `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: PartitionTuple([[1,1],[2],[2,1]]).contains( PartitionTuple([[1,1],[2],[2,1]]) )
        True

  `content`(k, r, c, multicharge)

    Returns 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: 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

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

        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

  `corners`()

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

    All indice 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: 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)]

  `diagram`()

    Return a string for the Ferrers diagram of `self`.

    EXAMPLES:

        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.global_options(convention="french")
        sage: print PartitionTuple([[3,2],[2,1],[],[1,1,1,1]]).diagram()
                          *
                          *
           **    *        *
           ***   **   -   *
        sage: PartitionTuples.global_options.reset()

  `dominates`(mu)

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

  `down`()

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

    EXAMPLES:

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

  `down_list`()

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

    EXAMPLES:

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

  `ferrers_diagram`()

    Return a string for the Ferrers diagram of `self`.

    EXAMPLES:

        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.global_options(convention="french")
        sage: print PartitionTuple([[3,2],[2,1],[],[1,1,1,1]]).diagram()
                          *
                          *
           **    *        *
           ***   **   -   *
        sage: PartitionTuples.global_options.reset()

  `garnir_tableau`(*cell)

    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 when 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: 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

    See also

    - `top_garnir_tableau()`
  `hook_length`(k, r, c)

    Return the length of the hook of cell `(k, r, c)` in the partition.

    The hook of cell `(k, r, c)` is defined as the cells to the right or below (in the English convention). If your coordinates are in the form `(k,r,c)`, use Python’s *-operator.

    EXAMPLES:

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

  `initial_tableau`()

    Return the `StandardTableauTuple` which has the numbers \(1, 2, \ldots, n\), where \(n\) is the `size()` of `self`, entered in order from left to right along the rows of each component, where the components are ordered from left to right.

    EXAMPLE:

        sage: PartitionTuple([ [2,1],[3,2] ]).initial_tableau()
        ([[1, 2], [3]], [[4, 5, 6], [7, 8]])

  `leg_length`(k, r, c)

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

    INPUT:

    - `k` – The compoenent
    - `r` – The row
    - `c` – The cell

    OUTPUT:

    - The leg length as an integer

    The leg of cell `(k, r, c)` is the number of cells in the `k`-th component which are below the node in row `r` and column `c`.

    EXAMPLES:

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

  `level`()

    Return the level of this partition tuple.

    The level is the length of the tuple.

    EXAMPLES:

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

  `outside_corners`()

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

  `pp`()

    Pretty prints this partition tuple. See `diagram()`.

    EXAMPLES:

        sage: PartitionTuple([[5,5,2,1],[3,2]]).pp()
        *****   ***
        *****   **
        **
        *

  `removable_cells`()

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

    All indice 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: 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)]

  `remove_cell`(k, r, c)

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

    This does not change `self`.

    EXAMPLES:

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

  `size`()

    Return the size of a partition tuple.

    EXAMPLES:

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

  `standard_tableaux`()

    Return the `standard tableau tuples` of this shape.

    EXAMPLE:

        sage: PartitionTuple([[],[3,2,2,1],[2,2,1],[3]]).standard_tableaux()
        Standard tableau tuples of shape ([], [3, 2, 2, 1], [2, 2, 1], [3])

  `to_exp`(k=0)

    Return a tuple of the multiplicities of the parts of a partition.

    Use the optional parameter `k` to get a return list of length at least `k`.

    EXAMPLES:

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

  `to_list`()

    Return `self` as a list of lists.

    EXAMPLES:

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

    TESTS:

        sage: all(mu==PartitionTuple(mu.to_list()) for mu in PartitionTuples(4,4))
        True

  `top_garnir_tableau`(e, cell)

    Return the most dominant standard tableau which dominates the corresponding Garnir tableau and has the same residue that has shape `self` and is determined by `e` and `cell`.

    The Garnir tableau 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 top Garnir tableaux arise in the graded representation theory of the symmetric groups and higher level Hecke algebras. They were introduced in [KMR].

    If the Garnir node is `cell=(k,r,c)` and \(m\) and \(M\) are the entries in the cells `(k,r,c)` and `(k,r+1,c)`, respectively, in the initial tableau then the top `e`-Garnir tableau is obtained by inserting the numbers \(m, m+1, \ldots, M\) in order from left to right first in the cells in row `r+1` which are not in the `e`-Garnir belt, then in the cell in rows `r` and `r+1` which are in the Garnir belt and then, finally, in the remaining cells in row `r` which are not in the Garnir belt. All other entries in the tableau remain unchanged.

    If `e = 0`, or if there are no `e`-bricks in either row `r` or `r+1`, then the top Garnir tableau is the corresponding Garnir tableau.

    EXAMPLES:

        sage: PartitionTuple([[3,3,2],[5,4,3,2]]).top_garnir_tableau(2,(1,0,2)).pp()
            1  2  3     9 10 12 13 16
            4  5  6    11 14 15 17
            7  8       18 19 20
                       21 22
        sage: PartitionTuple([[3,3,2],[5,4,3,2]]).top_garnir_tableau(2,(1,0,1)).pp()
            1  2  3     9 10 11 12 13
            4  5  6    14 15 16 17
            7  8       18 19 20
                       21 22
        sage: PartitionTuple([[3,3,2],[5,4,3,2]]).top_garnir_tableau(3,(1,0,1)).pp()
            1  2  3     9 12 13 14 15
            4  5  6    10 11 16 17
            7  8       18 19 20
                       21 22

        sage: PartitionTuple([[3,3,2],[5,4,3,2]]).top_garnir_tableau(3,(3,0,1)).pp()
        Traceback (most recent call last):
        ...
        ValueError: (comp, row+1, col) must be inside the diagram

    See also

    - `garnir_tableau()`

    REFERENCE:

    [KMR] | A. Kleshchev, A. Mathas, and A. Ram, Universal Specht modules for cyclotomic Hecke algebras, Proc. London Math. Soc. (2012) 105 (6): 1245-1289. Arxiv 1102.3519v1

  `up`()

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

    EXAMPLES:

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

  `up_list`()

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

    EXAMPLES:

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

  `young_subgroup`()

    Return the corresponding Young, or parabolic, subgroup of the symmetric group.

    EXAMPLE:

        sage: PartitionTuple([[2,1],[4,2],[1]]).young_subgroup()
        Permutation Group with generators [(), (8,9), (6,7), (5,6), (4,5), (1,2)]

  `young_subgroup_generators`()

    Return an indexing set for the generators of the corresponding Young subgroup.

    EXAMPLE:

        sage: PartitionTuple([[2,1],[4,2],[1]]).young_subgroup_generators()
        [1, 4, 5, 6, 8]

class `sage.combinat.partition_tuple.``PartitionTuples`

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

  List of all partition tuples.

  For more information about partition tuples, see `PartitionTuple`.

  This is a factory class which returns the appropriate parent based on the values of `level` and `size`.

  INPUT:

  - `level` – The length of the tuple
  - `size` – The total number of cells

  TESTS:

      sage: TestSuite( PartitionTuples() ).run()
      sage: TestSuite( PartitionTuples(level=4) ).run()
      sage: TestSuite( PartitionTuples(size=6) ).run()
      sage: TestSuite( PartitionTuples(level=4, size=5) ).run()

      sage: [ [2,1],[],[3] ] in PartitionTuples()
      True
      sage: ( [2,1],[],[3] ) in PartitionTuples()
      True
      sage: ( [] ) in PartitionTuples()
      True

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

      sage: 1 in PartitionTuples()
      False

  `Element`

    alias of `PartitionTuple`

  `global_options`(*get_value, **set_value)

    Sets and displays the global options for elements of the partition, skew partition, and partition tuple classes. If no parameters are set, then the function returns a copy of the options dictionary.

    The `options` to partitions can be accessed as the method `Partitions.global_options` of `Partitions` and related parent classes.

    OPTIONS:

    - `convention` – (default: `English`) Sets the convention used for displaying tableaux and partitions
      - `English` – use the English convention
      - `French` – use the French convention
    - `diagram_str` – (default: `*`) The character used for the cells when printing Ferrers diagrams
    - `display` – (default: `list`) Specifies how partitions should be printed
      - `array` – alias for `diagram`
      - `compact` – alias for `compact_low`
      - `compact_high` – compact form of `exp_high`
      - `compact_low` – compact form of `exp_low`
      - `diagram` – as a Ferrers diagram
      - `exp` – alias for `exp_low`
      - `exp_high` – in exponential form (highest first)
      - `exp_low` – in exponential form (lowest first)
      - `ferrers_diagram` – alias for `diagram`
      - `list` – displayed as a list
      - `young_diagram` – alias for `diagram`
    - `latex` – (default: `young_diagram`) Specifies how partitions should be latexed
      - `array` – alias for `diagram`
      - `diagram` – latex as a Ferrers diagram
      - `exp` – alias for `exp_low`
      - `exp_high` – latex as a list in exponential notation (highest first)
      - `exp_low` – as a list latex in exponential notation (lowest first)
      - `ferrers_diagram` – alias for `diagram`
      - `list` – latex as a list
      - `young_diagram` – latex as a Young diagram
    - `latex_diagram_str` – (default: `\ast`) The character used for the cells when latexing Ferrers diagrams
    - `notation` – alternative name for `convention`

    EXAMPLES:

        sage: P = Partition([4,2,2,1])
        sage: P
        [4, 2, 2, 1]
        sage: Partitions.global_options(display="exp")
        sage: P
        1, 2^2, 4
        sage: Partitions.global_options(display="exp_high")
        sage: P
        4, 2^2, 1

    It is also possible to use user defined functions for the `display` and `latex` options:

        sage: Partitions.global_options(display=lambda mu: '<%s>' % ','.join('%s'%m for m in mu._list)); P
        <4,2,2,1>
        sage: Partitions.global_options(latex=lambda mu: '\\Diagram{%s}' % ','.join('%s'%m for m in mu._list)); latex(P)
        \Diagram{4,2,2,1}
        sage: Partitions.global_options(display="diagram", diagram_str="#")
        sage: P
        ####
        ##
        ##
        #
        sage: Partitions.global_options(diagram_str="*", convention="french")
        sage: print P.ferrers_diagram()
        *
        **
        **
        ****

    Changing the `convention` for partitions also changes the `convention` option for tableaux and vice versa:

        sage: T = Tableau([[1,2,3],[4,5]])
        sage: T.pp()
          4  5
          1  2  3
        sage: Tableaux.global_options(convention="english")
        sage: print P.ferrers_diagram()
        ****
        **
        **
        *
        sage: T.pp()
          1  2  3
          4  5
        sage: Partitions.global_options.reset()

    See `GlobalOptions` for more features of these options.

  `level`()

    Return the level or `None` if it is not defined.

    EXAMPLES:

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

  `size`()

    Return the size or `None` if it is not defined.

    EXAMPLES:

        sage: PartitionTuples().size() is None
        True
        sage: PartitionTuples(size=7).size()
        7

class `sage.combinat.partition_tuple.``PartitionTuples_all`

  Bases: `sage.combinat.partition_tuple.PartitionTuples`

  Class of partition tuples of a arbitrary level and arbitrary sum.

class `sage.combinat.partition_tuple.``PartitionTuples_level`(level)

  Bases: `sage.combinat.partition_tuple.PartitionTuples`

  Class of partition tuples of a fixed level, but summing to an arbitrary integer.

class `sage.combinat.partition_tuple.``PartitionTuples_level_size`(level, size)

  Bases: `sage.combinat.partition_tuple.PartitionTuples`

  Class of partition tuples with a fixed level and a fixed size.

  `cardinality`()

    Returns the number of `level`-tuples of partitions of size `n`.

    Wraps a pari function call.

    EXAMPLES:

        sage: PartitionTuples(2,3).cardinality()
        10
        sage: PartitionTuples(2,8).cardinality()
        185

    TESTS:

    The following calls used to fail (trac ticket #11476):

        sage: PartitionTuples(17,2).cardinality()
        170
        sage: PartitionTuples(2,17).cardinality()
        8470
        sage: PartitionTuples(100,13).cardinality()
        110320020147886800
        sage: PartitionTuples(13,90).cardinality()
        91506473741200186152352843611

    These answers were checked against Gap4 (the last of which takes an awful long time for gap to compute).

class `sage.combinat.partition_tuple.``PartitionTuples_size`(size)

  Bases: `sage.combinat.partition_tuple.PartitionTuples`

  Class of partition tuples of a fixed size, but arbitrary level.

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »