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 Hecke algebras of type~A [BK].
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 (2016-07-01): 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 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
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 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,1]]) Standard (2,1|1|2,1^2)-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.TESTS:
sage: from sage.combinat.tableau_residues import ResidueSequence sage: TestSuite( ResidueSequence(3,(0,0,1), [0,1,2])).run(skip='_test_pickling')
-
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
.In more detail, in tis dictionary \(\beta[i]\) is equal to the number of nodes of residue
i
. This corresponds to\[\sum_{i\in I} \beta_i \alpha_i \in Q^+,\]a element of the positive root lattice of the corresponding Kac-Moody algebra.
This is a useful statistics because two Specht modules for a cyclotomic Hecke algebra of type \(A\) belong to the same block if and only if they correspond to same element \(\beta\) of the root lattice, given above.
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.
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() 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 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) 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)
-
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 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 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 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
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 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:
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 short-hand 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)) 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
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 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)
-