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 nonsemisimple 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 JucysMurphy 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 IwahoriHecke 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 ArikiKoike algebras.
The residue classes are constructed from standard tableaux:
sage: StandardTableau([[1,2],[3,4]]).residue_sequence(2)
2residue sequence (0,1,1,0) with multicharge (0)
sage: StandardTableau([[1,2],[3,4]]).residue_sequence(3)
3residue sequence (0,1,2,0) with multicharge (0)
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).residue_sequence(3,[0,0])
3residue sequence (0,1,2,0,0) with multicharge (0,0)
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).residue_sequence(3,[0,1])
3residue sequence (1,2,0,1,0) with multicharge (0,1)
sage: StandardTableauTuple([[[5]],[[1,2],[3,4]]]).residue_sequence(3,[0,2])
3residue 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 2residue 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 2residue 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 3residue 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:
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 (20160701): Initial version

class
sage.combinat.tableau_residues.
ResidueSequence
(parent, residues, check)¶ Bases:
sage.structure.list_clone.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 JucysMurphy elements upon all modules. More precisely, they index and completely determine the irreducible representations of the (cyclotomic) GelfandTsetlin algebras.
Rather than being called directly, residue sequences are best accessed via the standard tableaux classes
StandardTableau
andStandardTableauTuple
.INPUT:
Can be of the form:
ResidueSequence(e, res)
,ResidueSequence(e, multicharge, res)
,
where
e
is a positive integer not equal to 1 andres
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 3residue 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) 3residue sequence (0,2) with multicharge (0,2) sage: res.standard_tableaux([[2,1],[1],[2,1]]) Standard (2,112,1)tableaux with 3residue 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 3residue 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 sequenceself
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
ifself
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 thestandard_tableaux()
that belong to the residue class of tableaux determined byself
.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() 3residue 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^{e1} = 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 samequantum_characteristic()
andmulticharge()
.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) 3residue 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) 3residue 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) 3residue 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 samequantum_characteristic()
andmulticharge()
.EXAMPLES:
sage: from sage.combinat.tableau_residues import ResidueSequence sage: ResidueSequence(3, [0,1,2,2,0,1]).restrict_row((1,2),1) 3residue 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) 3residue sequence (2,0,1,0,1) with multicharge (1,0)

row_standard_tableaux
(shape=None)¶ Return the residueclass 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 residueclass of row standard tableaux, or row standard tableaux tuples, is returned. The residue sequenceself
specifies themulticharge()
of the tableaux which, in turn, determines thelevel()
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 3residue 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 (333)tableaux with 3residue 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 byself
.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 residueclass 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 residueclass of standard tableaux, or standard tableaux tuples, is returned. The residue sequenceself
specifies themulticharge()
of the tableaux which, in turn, determines thelevel()
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 3residue 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 (333)tableaux with 3residue 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
andj
– two integers between \(1\) and the length of the residue sequence
If residue sequence
self
is of Te 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 samequantum_characteristic()
andmulticharge()
, 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 3residue sequence (0,0,1,1,2,2,0,0) with multicharge (0,0,1) sage: ser = res.swap_residues(2,6); ser 3residue 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:
sage.structure.unique_representation.UniqueRepresentation
,sage.structure.parent.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 iscell_residue()
, which is a shorthand for computing the residue of a cell using theResidueSequence.quantum_characteristic()
andResidueSequence.multicharge()
for the residue class.EXAMPLES:
sage: from sage.combinat.tableau_residues import ResidueSequences sage: ResidueSequences(e=0, multicharge=(0,1,2)) 0residue 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
andc
– the row and column indices in level onek
,r
andc
– 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 multichargeself.multicharge()
.This is weak criteria in that we only require that
element
is a tuple of elements in the underlying base ring ofself
. 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 3residue 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 3residue 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 3residue sequence (2,0,1,1,2,2,0,0) with multicharge (0,0,1)
