Residue sequences of tableaux - Combinatorics

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

# Residue sequences of tableaux

A residue sequence for a `StandardTableau`, or `StandardTableauTuple`, of size \(n\) is an \(n\)-tuple \((i_1, i_2, \ldots, i_n)\) of elements of \(\ZZ / e\ZZ\) for some positive integer \(e \ge 1\). Such sequences arise in the representation theory of the symmetric group and the closely related cyclotomic Hecke algebras, and cyclotomic quiver Hecke algebras, where the residue sequences play a similar role to weights in the representations of Lie groups and Lie algebras. These Hecke algebras are semisimple when \(e\) is “large enough” and in these cases residue sequences are essentially the same as content sequences (see `sage.combinat.partition.Partition.content()`) and it is not difficult to see that residue sequences are in bijection with the set of standard tableaux. In the non-semisimple case, when \(e\) is “small”, different standard tableaux can have the same residue sequence. In this case the residue sequences describe how to decompose modules into generalised eigenspaces for the Jucys-Murphy elements for these algebras.

By definition, if \(t\) is a `StandardTableau` of size \(n\) then the residue sequence of \(t\) is the \(n\)-tuple \((i_1, \ldots, i_n)\) where \(i_m = c - r + e\ZZ\), if \(m\) appears in row \(r\) and column \(c\) of \(t\). If \(p\) is prime then such sequence arise in the representation theory of the symmetric group n characteristic \(p\). More generally, \(e\)-residue sequences arise in he representation theory of the Iwahori-Hecke algebra (see `IwahoriHeckeAlgebra`) the symmetric group with Hecke parameter at an \(e\)-th root of unity.

More generally, the \(e\)-residue sequence of a `StandardTableau` of size \(n\) and level \(l\) is the \(n\)-tuple \((i_1, \ldots, i_n)\) determined by \(e\) and a multicharge \(\kappa = (\kappa_1, \ldots, \kappa_l)\) by setting \(i_m = \kappa_k + c - r + e\ZZ\), if \(m\) appears in component \(k\), row \(r\) and column \(c\) of \(t\). These sequences arise in the representation theory of the cyclotomic Hecke algebras of type A, which are also known as Ariki-Koike algebras.

The residue classes are constructed from standard tableaux:

Sage

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

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

Python

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

    >>> StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue_sequence(Integer(3),[Integer(0),Integer(0)])
    3-residue sequence (0,1,2,0,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)

One of the most useful functions of a `ResidueSequence` is that it can return the `StandardTableaux_residue` and `StandardTableaux_residue_shape` that contain all of the tableaux with this residue sequence. Again, these are best accessed via the standard tableaux classes:

Sage

    sage: res = StandardTableau([[1,2],[3,4]]).residue_sequence(2)
    sage: res.standard_tableaux()
    Standard tableaux with 2-residue sequence (0,1,1,0) and multicharge (0)
    sage: res.standard_tableaux()[:]
    [[[1, 2, 4], [3]],
    [[1, 2], [3, 4]],
    [[1, 2], [3], [4]],
    [[1, 3, 4], [2]],
    [[1, 3], [2, 4]],
    [[1, 3], [2], [4]]]
    sage: res.standard_tableaux(shape=[4])
    Standard (4)-tableaux with 2-residue sequence (0,1,1,0) and multicharge (0)
    sage: res.standard_tableaux(shape=[4])[:]
    []

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

[Python]

    >>> from sage.all import *
    >>> res = StandardTableau([[Integer(1),Integer(2)],[Integer(3),Integer(4)]]).residue_sequence(Integer(2))
    >>> res.standard_tableaux()
    Standard tableaux with 2-residue sequence (0,1,1,0) and multicharge (0)
    >>> res.standard_tableaux()[:]
    [[[1, 2, 4], [3]],
    [[1, 2], [3, 4]],
    [[1, 2], [3], [4]],
    [[1, 3, 4], [2]],
    [[1, 3], [2, 4]],
    [[1, 3], [2], [4]]]
    >>> res.standard_tableaux(shape=[Integer(4)])
    Standard (4)-tableaux with 2-residue sequence (0,1,1,0) and multicharge (0)
    >>> res.standard_tableaux(shape=[Integer(4)])[:]
    []

    >>> res=StandardTableauTuple([[[Integer(5)]],[[Integer(1),Integer(2)],[Integer(3),Integer(4)]]]).residue_sequence(Integer(3),[Integer(0),Integer(0)])
    >>> res.standard_tableaux()
    Standard tableaux with 3-residue sequence (0,1,2,0,0) and multicharge (0,0)
    >>> res.standard_tableaux(shape=[[Integer(1)],[Integer(2),Integer(2)]])[:]
    [([[5]], [[1, 2], [3, 4]]), ([[4]], [[1, 2], [3, 5]])]

These residue sequences are particularly useful in the graded representation theory of the cyclotomic KLR algebras and the cyclotomic Hecke algebras of type~A; see [DJM1998] and [BK2009].

This module implements the following classes:

- `ResidueSequence`

- `ResidueSequences`

See also

- `Partitions`

- `PartitionTuples`

- `StandardTableaux_residue`

- `StandardTableaux_residue_shape`

- `RowStandardTableauTuples_residue`

- `RowStandardTableauTuples_residue_shape`

- `StandardTableaux`

- `StandardTableauTuples`

- `Tableaux`

- `TableauTuples`

Todo

Strictly speaking this module implements residue sequences of type \(A^{(1)}_e\). Residue sequences of other types also need to be implemented.

AUTHORS:

- Andrew Mathas (2016-07-01): Initial version

class sage.combinat.tableau_residues.ResidueSequence(parent, residues, check)

  Bases: `ClonableArray`

  A residue sequence.

  The residue sequence of a tableau \(t\) (of partition or partition tuple shape) is the sequence \((i_1, i_2, \ldots, i_n)\) where \(i_k\) is the residue of \(l\) in \(t\), for \(k = 1, 2, \ldots, n\), where \(n\) is the size of \(t\). Residue sequences are important in the representation theory of the cyclotomic Hecke algebras of type \(G(r, 1, n)\), and of the cyclotomic quiver Hecke algebras, because they determine the eigenvalues of the Jucys-Murphy elements upon all modules. More precisely, they index and completely determine the irreducible representations of the (cyclotomic) Gelfand-Tsetlin algebras.

  Rather than being called directly, residue sequences are best accessed via the standard tableaux classes `StandardTableau` and `StandardTableauTuple`.

  INPUT:

  Can be of the form:

  - `ResidueSequence(e, res)`,

  - `ResidueSequence(e, multicharge, res)`,

  where `e` is a positive integer not equal to 1 and `res` is a sequence of integers (the residues).

  EXAMPLES:

  Sage

      sage: res = StandardTableauTuple([[[1,3],[6]],[[2,7],[4],[5]]]).residue_sequence(3,(0,5))
      sage: res
      3-residue sequence (0,2,1,1,0,2,0) with multicharge (0,2)
      sage: res.quantum_characteristic()
      3
      sage: res.level()
      2
      sage: res.size()
      7
      sage: res.residues()
      [0, 2, 1, 1, 0, 2, 0]
      sage: res.restrict(2)
      3-residue sequence (0,2) with multicharge (0,2)
      sage: res.standard_tableaux([[2,1],[1],[2,1]])
      Standard (2,1|1|2,1)-tableaux with 3-residue sequence (0,2,1,1,0,2,0) and multicharge (0,2)
      sage: res.standard_tableaux([[2,2],[3]]).list()
      []
      sage: res.standard_tableaux([[2,2],[3]])[:]
      []
      sage: res.standard_tableaux()
      Standard tableaux with 3-residue sequence (0,2,1,1,0,2,0) and multicharge (0,2)
      sage: res.standard_tableaux()[:10]
      [([[1, 3, 6, 7], [2, 5], [4]], []),
       ([[1, 3, 6], [2, 5], [4], [7]], []),
       ([[1, 3], [2, 5], [4, 6], [7]], []),
       ([[1, 3], [2, 5], [4], [7]], [[6]]),
       ([[1, 3], [2, 5], [4]], [[6, 7]]),
       ([[1, 3, 6, 7], [2], [4], [5]], []),
       ([[1, 3, 6], [2, 7], [4], [5]], []),
       ([[1, 3], [2, 7], [4], [5], [6]], []),
       ([[1, 3], [2, 7], [4], [5]], [[6]]),
       ([[1, 3], [2], [4], [5]], [[6, 7]])]

  Python

      >>> from sage.all import *
      >>> res = StandardTableauTuple([[[Integer(1),Integer(3)],[Integer(6)]],[[Integer(2),Integer(7)],[Integer(4)],[Integer(5)]]]).residue_sequence(Integer(3),(Integer(0),Integer(5)))
      >>> res
      3-residue sequence (0,2,1,1,0,2,0) with multicharge (0,2)
      >>> res.quantum_characteristic()
      3
      >>> res.level()
      2
      >>> res.size()
      7
      >>> res.residues()
      [0, 2, 1, 1, 0, 2, 0]
      >>> res.restrict(Integer(2))
      3-residue sequence (0,2) with multicharge (0,2)
      >>> res.standard_tableaux([[Integer(2),Integer(1)],[Integer(1)],[Integer(2),Integer(1)]])
      Standard (2,1|1|2,1)-tableaux with 3-residue sequence (0,2,1,1,0,2,0) and multicharge (0,2)
      >>> res.standard_tableaux([[Integer(2),Integer(2)],[Integer(3)]]).list()
      []
      >>> res.standard_tableaux([[Integer(2),Integer(2)],[Integer(3)]])[:]
      []
      >>> res.standard_tableaux()
      Standard tableaux with 3-residue sequence (0,2,1,1,0,2,0) and multicharge (0,2)
      >>> res.standard_tableaux()[:Integer(10)]
      [([[1, 3, 6, 7], [2, 5], [4]], []),
       ([[1, 3, 6], [2, 5], [4], [7]], []),
       ([[1, 3], [2, 5], [4, 6], [7]], []),
       ([[1, 3], [2, 5], [4], [7]], [[6]]),
       ([[1, 3], [2, 5], [4]], [[6, 7]]),
       ([[1, 3, 6, 7], [2], [4], [5]], []),
       ([[1, 3, 6], [2, 7], [4], [5]], []),
       ([[1, 3], [2, 7], [4], [5], [6]], []),
       ([[1, 3], [2, 7], [4], [5]], [[6]]),
       ([[1, 3], [2], [4], [5]], [[6, 7]])]

  The TestSuite fails `_test_pickling` because `__getitem__` does not support slices, so we skip this.

  base_ring()

    Return the base ring for the residue sequence.

    If the `quantum_characteristic()` of the residue sequence `self` is \(e\) then the base ring for the sequence is \(\ZZ / e\ZZ\), or \(\ZZ\) if \(e=0\).

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,3]).base_ring()
        Ring of integers modulo 3

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), (Integer(0),Integer(0),Integer(1)), [Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).base_ring()
        Ring of integers modulo 3

  block()

    Return a dictionary \(\beta\) that determines the block associated to the residue sequence `self`.

    Two Specht modules for a cyclotomic Hecke algebra of type \(A\) belong to the same block, in this sense, if and only if the residue sequences of their standard tableaux have the same block in this sense. The blocks of these algebras are actually indexed by positive roots in the root lattice of an affine special linear group. Instead of than constructing the root lattice, this method simply returns a dictionary \(\beta\) where the keys are residues \(i\) and where the value of the key \(i\) is equal to the numbers of nodes in the residue sequence `self` that are equal to \(i\). The dictionary \(\beta\) corresponds to the positive root:

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

    These positive roots also index the blocks of the cyclotomic KLR algebras of type \(A\).

    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, which is infinite.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, [0,0,0], [0,1,2,0,1,2,0,1,2]).block()
        {0: 3, 1: 3, 2: 3}

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), [Integer(0),Integer(0),Integer(0)], [Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2)]).block()
        {0: 3, 1: 3, 2: 3}

  check()

    Raise a `ValueError` if `self` is not a residue sequence.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, [0,0,1], [0,0,1,1,2,2,3,3]).check()
        sage: ResidueSequence(3, [0,0,1], [2,0,1,1,2,2,3,3]).check()

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), [Integer(0),Integer(0),Integer(1)], [Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).check()
        >>> ResidueSequence(Integer(3), [Integer(0),Integer(0),Integer(1)], [Integer(2),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).check()

  level()

    Return the level of the residue sequence. That is, the level of the corresponding (tuples of) standard tableaux.

    The level of a residue sequence is the length of its `multicharge()`. This is the same as the level of the `standard_tableaux()` that belong to the residue class of tableaux determined by `self`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,3]).level()
        3

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), (Integer(0),Integer(0),Integer(1)), [Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).level()
        3

  multicharge()

    Return the multicharge for the residue sequence `self`.

    The \(e\)-residue sequences are associated with a cyclotomic Hecke algebra with Hecke parameter \(q\) of `quantum_characteristic()` \(e\) and multicharge \((\kappa_1, \ldots, \kappa_l)\). This means that the cyclotomic parameters of the Hecke algebra are \(q^{\kappa_1}, \ldots, q^{\kappa_l}\). Equivalently, the Hecke algebra is determined by the dominant weight

    \[\sum_{r \in \ZZ / e\ZZ} \kappa_r \Lambda_r \in P^+.\]

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,3]).multicharge()
        (0, 0, 1)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), (Integer(0),Integer(0),Integer(1)), [Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).multicharge()
        (0, 0, 1)

  negative()

    Return the negative of the residue sequence `self`.

    That is, if `self` is the residue sequence \((i_1, \ldots, i_n)\) then return \((-i_1, \ldots, -i_n)\). Taking the negative residue sequences is a shadow of tensoring with the sign representation from the cyclotomic Hecke algebras of type \(A\).

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3,[0,0,1],[0,0,1,1,2,2,3,3]).negative()
        3-residue sequence (0,0,2,2,1,1,0,0) with multicharge (0,0,1)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3),[Integer(0),Integer(0),Integer(1)],[Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).negative()
        3-residue sequence (0,0,2,2,1,1,0,0) with multicharge (0,0,1)

  quantum_characteristic()

    Return the quantum characteristic of the residue sequence `self`.

    The \(e\)-residue sequences are associated with a cyclotomic Hecke algebra that has a parameter \(q\) of quantum characteristic \(e\). This is the smallest positive integer such that \(1 + q + \cdots + q^{e-1} = 0\), or \(e=0\) if no such integer exists.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,3]).quantum_characteristic()
        3

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), (Integer(0),Integer(0),Integer(1)), [Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).quantum_characteristic()
        3

  residues()

    Return a list of the residue sequence.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3,(0,0,1),[0,0,1,1,2,2,3,3]).residues()
        [0, 0, 1, 1, 2, 2, 0, 0]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).residues()
        [0, 0, 1, 1, 2, 2, 0, 0]

  restrict(m)

    Return the subsequence of this sequence of length \(m\).

    The residue sequence `self` is of the form \((r_1, \ldots, r_n)\). The function returns the residue sequence \((r_1, \ldots, r_m)\), with the same `quantum_characteristic()` and `multicharge()`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3,(0,0,1),[0,0,1,1,2,2,3,3]).restrict(7)
        3-residue sequence (0,0,1,1,2,2,0) with multicharge (0,0,1)
        sage: ResidueSequence(3,(0,0,1),[0,0,1,1,2,2,3,3]).restrict(6)
        3-residue sequence (0,0,1,1,2,2) with multicharge (0,0,1)
        sage: ResidueSequence(3,(0,0,1),[0,0,1,1,2,2,3,3]).restrict(4)
        3-residue sequence (0,0,1,1) with multicharge (0,0,1)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).restrict(Integer(7))
        3-residue sequence (0,0,1,1,2,2,0) with multicharge (0,0,1)
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).restrict(Integer(6))
        3-residue sequence (0,0,1,1,2,2) with multicharge (0,0,1)
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).restrict(Integer(4))
        3-residue sequence (0,0,1,1) with multicharge (0,0,1)

  restrict_row(cell, row)

    Return a residue sequence for the tableau obtained by swapping the row in ending in \(cell\) with the row that is \(row\) rows above it and which has the same length.

    The residue sequence `self` is of the form \((r_1, \ldots, r_n)\). The function returns the residue sequence \((r_1, \ldots, r_m)\), with the same `quantum_characteristic()` and `multicharge()`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, [0,1,2,2,0,1]).restrict_row((1,2),1)
        3-residue sequence (2,0,1,0,1) with multicharge (0)
        sage: ResidueSequence(3, [1,0], [0,1,2,2,0,1]).restrict_row((1,1,2),1)
        3-residue sequence (2,0,1,0,1) with multicharge (1,0)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), [Integer(0),Integer(1),Integer(2),Integer(2),Integer(0),Integer(1)]).restrict_row((Integer(1),Integer(2)),Integer(1))
        3-residue sequence (2,0,1,0,1) with multicharge (0)
        >>> ResidueSequence(Integer(3), [Integer(1),Integer(0)], [Integer(0),Integer(1),Integer(2),Integer(2),Integer(0),Integer(1)]).restrict_row((Integer(1),Integer(1),Integer(2)),Integer(1))
        3-residue sequence (2,0,1,0,1) with multicharge (1,0)

  row_standard_tableaux(shape=None)

    Return the residue-class of row standard tableaux that have residue sequence `self`.

    INPUT:

    - `shape` – (optional) a partition or partition tuple of the correct level

    OUTPUT:

    An iterator for the row standard tableaux with this residue sequence. If the `shape` is given then only tableaux of this shape are returned, otherwise all of the full residue-class of row standard tableaux, or row standard tableaux tuples, is returned. The residue sequence `self` specifies the `multicharge()` of the tableaux which, in turn, determines the `level()` of the tableaux in the residue class.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3,(0,0,0),[0,1,2,0,1,2,0,1,2]).row_standard_tableaux()
        Row standard tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)
        sage: ResidueSequence(3,(0,0,0),[0,1,2,0,1,2,0,1,2]).row_standard_tableaux([[3],[3],[3]])
        Row standard (3|3|3)-tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(0)),[Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2)]).row_standard_tableaux()
        Row standard tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(0)),[Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2)]).row_standard_tableaux([[Integer(3)],[Integer(3)],[Integer(3)]])
        Row standard (3|3|3)-tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)

  size()

    Return the size of the residue sequence.

    This is the size, or length, of the residue sequence, which is the same as the size of the `standard_tableaux()` that belong to the residue class of tableaux determined by `self`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,3]).size()
        8

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3), (Integer(0),Integer(0),Integer(1)), [Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]).size()
        8

  standard_tableaux(shape=None)

    Return the residue-class of standard tableaux that have residue sequence `self`.

    INPUT:

    - `shape` – (optional) a partition or partition tuple of the correct level

    OUTPUT:

    An iterator for the standard tableaux with this residue sequence. If the `shape` is given then only tableaux of this shape are returned, otherwise all of the full residue-class of standard tableaux, or standard tableaux tuples, is returned. The residue sequence `self` specifies the `multicharge()` of the tableaux which, in turn, determines the `level()` of the tableaux in the residue class.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3,(0,0,0),[0,1,2,0,1,2,0,1,2]).standard_tableaux()
        Standard tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)
        sage: ResidueSequence(3,(0,0,0),[0,1,2,0,1,2,0,1,2]).standard_tableaux([[3],[3],[3]])
        Standard (3|3|3)-tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(0)),[Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2)]).standard_tableaux()
        Standard tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(0)),[Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2),Integer(0),Integer(1),Integer(2)]).standard_tableaux([[Integer(3)],[Integer(3)],[Integer(3)]])
        Standard (3|3|3)-tableaux with 3-residue sequence (0,1,2,0,1,2,0,1,2) and multicharge (0,0,0)

  swap_residues(i, j)

    Return the new residue sequence obtained by swapping the residues for `i` and `j`.

    INPUT:

    - `i`, `j` – two integers between \(1\) and the length of the residue sequence

    If residue sequence `self` is of the form \((r_1, \ldots, r_n)\), and \(i < j\), then the residue sequence \((r_1, \ldots, r_j, \ldots, r_i, \ldots, r_m)\), with the same `quantum_characteristic()` and `multicharge()`, is returned.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: res = ResidueSequence(3,(0,0,1),[0,0,1,1,2,2,3,3]); res
        3-residue sequence (0,0,1,1,2,2,0,0) with multicharge (0,0,1)
        sage: ser = res.swap_residues(2,6); ser
        3-residue sequence (0,2,1,1,2,0,0,0) with multicharge (0,0,1)
        sage: res == ser
        False

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> res = ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]); res
        3-residue sequence (0,0,1,1,2,2,0,0) with multicharge (0,0,1)
        >>> ser = res.swap_residues(Integer(2),Integer(6)); ser
        3-residue sequence (0,2,1,1,2,0,0,0) with multicharge (0,0,1)
        >>> res == ser
        False

class sage.combinat.tableau_residues.ResidueSequences(e, multicharge=(0,))

  Bases: `UniqueRepresentation`, `Parent`

  A parent class for `ResidueSequence`.

  This class exists because `ResidueSequence` needs to have a parent. Apart form being a parent the only useful method that it provides is `cell_residue()`, which is a short-hand for computing the residue of a cell using the `ResidueSequence.quantum_characteristic()` and `ResidueSequence.multicharge()` for the residue class.

  EXAMPLES:

  Sage

      sage: from sage.combinat.tableau_residues import ResidueSequences
      sage: ResidueSequences(e=0, multicharge=(0,1,2))
      0-residue sequences with multicharge (0, 1, 2)
      sage: ResidueSequences(e=0, multicharge=(0,1,2)) == ResidueSequences(e=0, multicharge=(0,1,2))
      True
      sage: ResidueSequences(e=0, multicharge=(0,1,2)) == ResidueSequences(e=3, multicharge=(0,1,2))
      False
      sage: ResidueSequences(e=0, multicharge=(0,1,2)).element_class
      <class 'sage.combinat.tableau_residues.ResidueSequences_with_category.element_class'>

  Python

      >>> from sage.all import *
      >>> from sage.combinat.tableau_residues import ResidueSequences
      >>> ResidueSequences(e=Integer(0), multicharge=(Integer(0),Integer(1),Integer(2)))
      0-residue sequences with multicharge (0, 1, 2)
      >>> ResidueSequences(e=Integer(0), multicharge=(Integer(0),Integer(1),Integer(2))) == ResidueSequences(e=Integer(0), multicharge=(Integer(0),Integer(1),Integer(2)))
      True
      >>> ResidueSequences(e=Integer(0), multicharge=(Integer(0),Integer(1),Integer(2))) == ResidueSequences(e=Integer(3), multicharge=(Integer(0),Integer(1),Integer(2)))
      False
      >>> ResidueSequences(e=Integer(0), multicharge=(Integer(0),Integer(1),Integer(2))).element_class
      <class 'sage.combinat.tableau_residues.ResidueSequences_with_category.element_class'>

  Element

    alias of `ResidueSequence`

  cell_residue(*args)

    Return the residue a cell with respect to the quantum characteristic and the multicharge of the residue sequence.

    INPUT:

    - `r`, `c` – the row and column indices in level one

    - `k`, `r`, `c` – the component, row and column indices in higher levels

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequences
        sage: ResidueSequences(3).cell_residue(1,1)
        0
        sage: ResidueSequences(3).cell_residue(2,1)
        2
        sage: ResidueSequences(3).cell_residue(3,1)
        1
        sage: ResidueSequences(3).cell_residue(3,2)
        2
        sage: ResidueSequences(3,(0,1,2)).cell_residue(0,0,0)
        0
        sage: ResidueSequences(3,(0,1,2)).cell_residue(0,1,0)
        2
        sage: ResidueSequences(3,(0,1,2)).cell_residue(0,1,2)
        1
        sage: ResidueSequences(3,(0,1,2)).cell_residue(1,0,0)
        1
        sage: ResidueSequences(3,(0,1,2)).cell_residue(1,1,0)
        0
        sage: ResidueSequences(3,(0,1,2)).cell_residue(1,0,1)
        2
        sage: ResidueSequences(3,(0,1,2)).cell_residue(2,0,0)
        2
        sage: ResidueSequences(3,(0,1,2)).cell_residue(2,1,0)
        1
        sage: ResidueSequences(3,(0,1,2)).cell_residue(2,0,1)
        0

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequences
        >>> ResidueSequences(Integer(3)).cell_residue(Integer(1),Integer(1))
        0
        >>> ResidueSequences(Integer(3)).cell_residue(Integer(2),Integer(1))
        2
        >>> ResidueSequences(Integer(3)).cell_residue(Integer(3),Integer(1))
        1
        >>> ResidueSequences(Integer(3)).cell_residue(Integer(3),Integer(2))
        2
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(0),Integer(0),Integer(0))
        0
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(0),Integer(1),Integer(0))
        2
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(0),Integer(1),Integer(2))
        1
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(1),Integer(0),Integer(0))
        1
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(1),Integer(1),Integer(0))
        0
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(1),Integer(0),Integer(1))
        2
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(2),Integer(0),Integer(0))
        2
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(2),Integer(1),Integer(0))
        1
        >>> ResidueSequences(Integer(3),(Integer(0),Integer(1),Integer(2))).cell_residue(Integer(2),Integer(0),Integer(1))
        0

  check_element(element)

    Check that `element` is a residue sequence with multicharge `self.multicharge()`.

    This is weak criteria in that we only require that `element` is a tuple of elements in the underlying base ring of `self`. Such a sequence is always a valid residue sequence, although there may be no tableaux with this residue sequence.

    EXAMPLES:

    Sage

        sage: from sage.combinat.tableau_residues import ResidueSequence
        sage: ResidueSequence(3,(0,0,1),[0,0,1,1,2,2,3,3]) # indirect doctest
        3-residue sequence (0,0,1,1,2,2,0,0) with multicharge (0,0,1)
        sage: ResidueSequence(3,(0,0,1),[2,0,1,4,2,2,5,3]) # indirect doctest
        3-residue sequence (2,0,1,1,2,2,2,0) with multicharge (0,0,1)
        sage: ResidueSequence(3,(0,0,1),[2,0,1,1,2,2,3,3]) # indirect doctest
        3-residue sequence (2,0,1,1,2,2,0,0) with multicharge (0,0,1)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.tableau_residues import ResidueSequence
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(0),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]) # indirect doctest
        3-residue sequence (0,0,1,1,2,2,0,0) with multicharge (0,0,1)
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(2),Integer(0),Integer(1),Integer(4),Integer(2),Integer(2),Integer(5),Integer(3)]) # indirect doctest
        3-residue sequence (2,0,1,1,2,2,2,0) with multicharge (0,0,1)
        >>> ResidueSequence(Integer(3),(Integer(0),Integer(0),Integer(1)),[Integer(2),Integer(0),Integer(1),Integer(1),Integer(2),Integer(2),Integer(3),Integer(3)]) # indirect doctest
        3-residue sequence (2,0,1,1,2,2,0,0) with multicharge (0,0,1)