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

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

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

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

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

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

check()#

Raise a ValueError if self is not a residue sequence.

EXAMPLES:

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

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: from sage.combinat.tableau_residues import ResidueSequence
sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,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: 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)

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

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: from sage.combinat.tableau_residues import ResidueSequence
sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,3]).quantum_characteristic()
3

residues()#

Return a list of the residue sequence.

EXAMPLES:

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]

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

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

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

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: from sage.combinat.tableau_residues import ResidueSequence
sage: ResidueSequence(3, (0,0,1), [0,0,1,1,2,2,3,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: 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)

swap_residues(i, j)#

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

INPUT:

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

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

Element#: alias of ResidueSequence

an_element()#

Return a particular element of self.

EXAMPLES:

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

cell_residue(*args)#

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

INPUT:

r and c – the row and column indices in level one
k, r and c – the component, row and column indices in higher levels

EXAMPLES:

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

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