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

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)[source]¶

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

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

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

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

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

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

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

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

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)[source]¶

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)[source]¶

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)[source]¶

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

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)[source]¶

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)[source]¶

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,))[source]¶

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[source]¶: alias of ResidueSequence

an_element()[source]¶

Return a particular element of self.

EXAMPLES:

Sage

sage: TableauTuples().an_element()
([[1]], [[2]], [[3]], [[4]], [[5]], [[6]], [[7]])

Python

>>> from sage.all import *
>>> TableauTuples().an_element()
([[1]], [[2]], [[3]], [[4]], [[5]], [[6]], [[7]])

cell_residue(*args)[source]¶

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)[source]¶

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)