Kleshchev partitions

---

A partition (tuple) \(\mu\) is Kleshchev if it can be recursively obtained by adding a sequence of good nodes to the empty PartitionTuple of the same level() and multicharge. In this way, the set of Kleshchev multipartitions becomes a realization of a Kashiwara crystal sage.combinat.crystals.crystals for a irreducible integral highest weight representation of \(U_q(\widehat{\mathfrak{sl}}_e)\).

The Kleshchev multipartitions first appeared in the work of Ariki and Mathas [AM2000] where it was shown that they index the irreducible representations of the cyclotomic Hecke algebras of type \(A\) [AK1994]. Soon afterwards Ariki [Ariki2001] showed that the set of Kleshchev multipartitions naturally label the irreducible representations of these algebras. As a far reaching generalization of these ideas the Ariki-Brundan-Kleshchev categorification theorem [Ariki1996] [BK2009] says that these algebras categorify the irreducible integral highest weight representations of the quantum group \(U_q(\widehat{\mathfrak{sl}}_e)\) of the affine special linear group. Under this categorification, \(q\) corresponds to the grading shift on the cyclotomic Hecke algebras, where the grading from the Brundan-Kleshchev graded isomorphism theorem to the KLR algebras of type \(A\) [BK2009].

The group algebras of the symmetric group in characteristic \(p\) are an important special case of the cyclotomic Hecke algebras of type \(A\). In this case, depending on your prefer convention, the set of Kleshchev partitions is the set of `p`-regular or `p`-restricted Partitions. In this case, Kleshchev [Kle1995] proved that the modular branching rules were given by adding and removing good nodes; see good_cells(). Lascoux, Leclerc and Thibon [LLT1996] noticed that Kleshchev’s branching rules coincided with Kashiwara’s crystal operators for the fundamental representation of \(L(\Lambda_0)\) of \(U_q(\widehat{\mathfrak{sl}}_p)\) and their celebrated LLT conjecture said that decomposition matrices of the sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra of the symmetric group should be computable using the canonical basis of \(L(\Lambda_0)\). This was proved and generalised to all cyclotomic Hecke algebras of type \(A\) by Ariki [Ariki1996] and then further generalized to the graded setting by Brundan and Kleshchev [BK2009].

The main class for accessing Kleshchev partition (tuples) is KleshchevPartitions. Unfortunately, just as with the symmetric group, different authors use different conventions when defining Kleshchev partitions, which depends on whether you read components from left to right, or right to left, and whether you read the nodes in the partition in each component from top to bottom or bottom to top. The KleshchevPartitions class supports these four different conventions:

Sage

sage: KleshchevPartitions(2, [0,0], size=2, convention='left regular')[:]
[([1], [1]), ([2], [])]
sage: KleshchevPartitions(2, [0,0], size=2, convention='left restricted')[:]
[([1], [1]), ([], [1, 1])]
sage: KleshchevPartitions(2, [0,0], size=2, convention='right regular')[:]
[([1], [1]), ([], [2])]
sage: KleshchevPartitions(2, [0,0], size=2, convention='right restricted')[:]
[([1], [1]), ([1, 1], [])]

Python

>>> from sage.all import *
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left regular')[:]
[([1], [1]), ([2], [])]
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left restricted')[:]
[([1], [1]), ([], [1, 1])]
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='right regular')[:]
[([1], [1]), ([], [2])]
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='right restricted')[:]
[([1], [1]), ([1, 1], [])]

Sage Live

KleshchevPartitions(2, [0,0], size=2, convention='left regular')[:]
KleshchevPartitions(2, [0,0], size=2, convention='left restricted')[:]
KleshchevPartitions(2, [0,0], size=2, convention='right regular')[:]
KleshchevPartitions(2, [0,0], size=2, convention='right restricted')[:]

By default, the left restricted convention is used. As a shorthand, LG, LS, RG and RS, respectively, can be used to specify the convention With the left convention the partition tuples should be ordered with the most dominant partitions in the partition tuple on the left and with the right convention the most dominant partition is on the right.

The KleshchevPartitions class can automatically convert between these four different conventions:

Sage

sage: KPlg = KleshchevPartitions(2, [0,0], size=2, convention='left regular')
sage: KPls = KleshchevPartitions(2, [0,0], size=2, convention='left restricted')
sage: [KPlg(mu) for mu in KPls] # indirect doc test
[([1], [1]), ([2], [])]

Python

>>> from sage.all import *
>>> KPlg = KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left regular')
>>> KPls = KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left restricted')
>>> [KPlg(mu) for mu in KPls] # indirect doc test
[([1], [1]), ([2], [])]

Sage Live

KPlg = KleshchevPartitions(2, [0,0], size=2, convention='left regular')
KPls = KleshchevPartitions(2, [0,0], size=2, convention='left restricted')
[KPlg(mu) for mu in KPls] # indirect doc test

AUTHORS:

• Andrew Mathas and Travis Scrimshaw (2018-05-1): Initial version

class sage.combinat.partition_kleshchev.KleshchevCrystalMixin

Bases: object

Mixin class for the crystal structure of a Kleshchev partition.

Epsilon()

Return \(\varepsilon\) of self.

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: x = C([[5,4,1],[3,2,1,1]])
sage: x.Epsilon()
3*Lambda[1]

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> x = C([[Integer(5),Integer(4),Integer(1)],[Integer(3),Integer(2),Integer(1),Integer(1)]])
>>> x.Epsilon()
3*Lambda[1]

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
x = C([[5,4,1],[3,2,1,1]])
x.Epsilon()

Phi()

Return \(\phi\) of self.

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: x = C([[5,4,1],[3,2,1,1]])
sage: x.Phi()
3*Lambda[0] + 2*Lambda[1]

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> x = C([[Integer(5),Integer(4),Integer(1)],[Integer(3),Integer(2),Integer(1),Integer(1)]])
>>> x.Phi()
3*Lambda[0] + 2*Lambda[1]

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
x = C([[5,4,1],[3,2,1,1]])
x.Phi()

epsilon(i)

Return the Kashiwara crystal operator \(\varepsilon_i\) applied to self.

INPUT:

• i – an element of the index set

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: x = C([[5,4,1],[3,2,1,1]])
sage: [x.epsilon(i) for i in C.index_set()]
[0, 3, 0]

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> x = C([[Integer(5),Integer(4),Integer(1)],[Integer(3),Integer(2),Integer(1),Integer(1)]])
>>> [x.epsilon(i) for i in C.index_set()]
[0, 3, 0]

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
x = C([[5,4,1],[3,2,1,1]])
[x.epsilon(i) for i in C.index_set()]

phi(i)

Return the Kashiwara crystal operator \(\varphi_i\) applied to self.

INPUT:

• i – an element of the index set

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: x = C([[5,4,1],[3,2,1,1]])
sage: [x.phi(i) for i in C.index_set()]
[3, 2, 0]

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> x = C([[Integer(5),Integer(4),Integer(1)],[Integer(3),Integer(2),Integer(1),Integer(1)]])
>>> [x.phi(i) for i in C.index_set()]
[3, 2, 0]

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
x = C([[5,4,1],[3,2,1,1]])
[x.phi(i) for i in C.index_set()]

weight()

Return the weight of self.

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: x = C([[5,4,1], [3,2,1,1]])
sage: x.weight()
3*Lambda[0] - Lambda[1] - 5*delta
sage: x.Phi() - x.Epsilon()
3*Lambda[0] - Lambda[1]

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="right regular")
sage: y = C([[5,1,1], [4,2,2,1,1]])
sage: y.weight()
6*Lambda[0] - 4*Lambda[1] - 4*delta
sage: y.Phi() - y.Epsilon()
6*Lambda[0] - 4*Lambda[1]

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: y = C([[5,1,1], [4,2,2,1,1]])
sage: y.weight()
6*Lambda[0] - 4*Lambda[1] - 4*delta
sage: y.Phi() - y.Epsilon()
6*Lambda[0] - 4*Lambda[1]

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> x = C([[Integer(5),Integer(4),Integer(1)], [Integer(3),Integer(2),Integer(1),Integer(1)]])
>>> x.weight()
3*Lambda[0] - Lambda[1] - 5*delta
>>> x.Phi() - x.Epsilon()
3*Lambda[0] - Lambda[1]

>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="right regular")
>>> y = C([[Integer(5),Integer(1),Integer(1)], [Integer(4),Integer(2),Integer(2),Integer(1),Integer(1)]])
>>> y.weight()
6*Lambda[0] - 4*Lambda[1] - 4*delta
>>> y.Phi() - y.Epsilon()
6*Lambda[0] - 4*Lambda[1]

>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> y = C([[Integer(5),Integer(1),Integer(1)], [Integer(4),Integer(2),Integer(2),Integer(1),Integer(1)]])
>>> y.weight()
6*Lambda[0] - 4*Lambda[1] - 4*delta
>>> y.Phi() - y.Epsilon()
6*Lambda[0] - 4*Lambda[1]

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
x = C([[5,4,1], [3,2,1,1]])
x.weight()
x.Phi() - x.Epsilon()
C = crystals.KleshchevPartitions(3, [0,2], convention="right regular")
y = C([[5,1,1], [4,2,2,1,1]])
y.weight()
y.Phi() - y.Epsilon()
C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
y = C([[5,1,1], [4,2,2,1,1]])
y.weight()
y.Phi() - y.Epsilon()

class sage.combinat.partition_kleshchev.KleshchevPartition(parent, mu)

Bases: Partition

Abstract base class for Kleshchev partitions. See KleshchevPartitions.

cogood_cells(i=None)

Return a list of the cells of self that are cogood.

The cogood \(i\)-cell is the ‘last’ conormal \(i\)-cell. As with the conormal cells we can choose to read either up or down the partition as specified by convention().

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of cogood cells is returned, which gives the cogood cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, convention='regular')
sage: KP([5,4,4,3,2]).cogood_cells()
{0: (1, 4), 1: (4, 2)}
sage: KP([5,4,4,3,2]).cogood_cells(0)
(1, 4)
sage: KP([5,4,4,3,2]).cogood_cells(1)
(4, 2)
sage: KP = KleshchevPartitions(4, convention='restricted')
sage: KP([5,4,4,3,2]).cogood_cells()
{1: (0, 5), 2: (4, 2), 3: (1, 4)}
sage: KP([5,4,4,3,2]).cogood_cells(0)
sage: KP([5,4,4,3,2]).cogood_cells(2)
(4, 2)

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), convention='regular')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).cogood_cells()
{0: (1, 4), 1: (4, 2)}
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).cogood_cells(Integer(0))
(1, 4)
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).cogood_cells(Integer(1))
(4, 2)
>>> KP = KleshchevPartitions(Integer(4), convention='restricted')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).cogood_cells()
{1: (0, 5), 2: (4, 2), 3: (1, 4)}
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).cogood_cells(Integer(0))
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).cogood_cells(Integer(2))
(4, 2)

Sage Live

KP = KleshchevPartitions(3, convention='regular')
KP([5,4,4,3,2]).cogood_cells()
KP([5,4,4,3,2]).cogood_cells(0)
KP([5,4,4,3,2]).cogood_cells(1)
KP = KleshchevPartitions(4, convention='restricted')
KP([5,4,4,3,2]).cogood_cells()
KP([5,4,4,3,2]).cogood_cells(0)
KP([5,4,4,3,2]).cogood_cells(2)

conormal_cells(i=None)

Return a dictionary of the cells of self which are conormal.

Following [Kle1995], the conormal cells are computed by reading up (or down) the rows of the partition and marking all of the addable and removable cells of \(e\)-residue \(i\) and then recursively removing all adjacent pairs of removable and addable cells (in that order) from this list. The addable \(i\)-cells that remain at the end of the this process are the conormal \(i\)-cells.

When computing conormal cells you can either read the cells in order from top to bottom (this corresponds to labeling the simple modules of the symmetric group by regular partitions) or from bottom to top (corresponding to labeling the simples by restricted partitions). By default we read down the partition but this can be changed by setting convention = 'RS'.

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of conormal cells is returned, which gives the conormal cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, convention='regular')
sage: KP([5,4,4,3,2]).conormal_cells()
{0: [(1, 4)], 1: [(5, 0), (4, 2)]}
sage: KP([5,4,4,3,2]).conormal_cells(0)
[(1, 4)]
sage: KP([5,4,4,3,2]).conormal_cells(1)
[(5, 0), (4, 2)]
sage: KP = KleshchevPartitions(3, convention='restricted')
sage: KP([5,4,4,3,2]).conormal_cells()
{0: [(1, 4), (3, 3)], 2: [(0, 5)]}

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), convention='regular')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).conormal_cells()
{0: [(1, 4)], 1: [(5, 0), (4, 2)]}
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).conormal_cells(Integer(0))
[(1, 4)]
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).conormal_cells(Integer(1))
[(5, 0), (4, 2)]
>>> KP = KleshchevPartitions(Integer(3), convention='restricted')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).conormal_cells()
{0: [(1, 4), (3, 3)], 2: [(0, 5)]}

Sage Live

KP = KleshchevPartitions(3, convention='regular')
KP([5,4,4,3,2]).conormal_cells()
KP([5,4,4,3,2]).conormal_cells(0)
KP([5,4,4,3,2]).conormal_cells(1)
KP = KleshchevPartitions(3, convention='restricted')
KP([5,4,4,3,2]).conormal_cells()

good_cell_sequence()

Return a sequence of good nodes from the empty partition to self, or None if no such sequence exists.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, convention='regular')
sage: KP([5,4,4,3,2]).good_cell_sequence()
[(0, 0), (1, 0), (0, 1), (2, 0), (1, 1), (0, 2),
 (3, 0), (2, 1), (1, 2), (3, 1), (0, 3), (1, 3),
 (2, 2), (3, 2), (4, 0), (4, 1), (0, 4), (2, 3)]
sage: KP = KleshchevPartitions(3, convention='restricted')
sage: KP([5,4,4,3,2]).good_cell_sequence()
[(0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0),
 (0, 3), (2, 1), (1, 2), (1, 3), (3, 0), (3, 1),
 (2, 2), (4, 0), (2, 3), (3, 2), (0, 4), (4, 1)]

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), convention='regular')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_cell_sequence()
[(0, 0), (1, 0), (0, 1), (2, 0), (1, 1), (0, 2),
 (3, 0), (2, 1), (1, 2), (3, 1), (0, 3), (1, 3),
 (2, 2), (3, 2), (4, 0), (4, 1), (0, 4), (2, 3)]
>>> KP = KleshchevPartitions(Integer(3), convention='restricted')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_cell_sequence()
[(0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0),
 (0, 3), (2, 1), (1, 2), (1, 3), (3, 0), (3, 1),
 (2, 2), (4, 0), (2, 3), (3, 2), (0, 4), (4, 1)]

Sage Live

KP = KleshchevPartitions(3, convention='regular')
KP([5,4,4,3,2]).good_cell_sequence()
KP = KleshchevPartitions(3, convention='restricted')
KP([5,4,4,3,2]).good_cell_sequence()

good_cells(i=None)

Return a list of the cells of self that are good.

The good \(i\)-cell is the ‘first’ normal \(i\)-cell. As with the normal cells we can choose to read either up or down the partition as specified by convention().

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of good cells is returned, which gives the good cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP3 = KleshchevPartitions(3, convention='regular')
sage: KP3([5,4,4,3,2]).good_cells()
{1: (2, 3)}
sage: KP3([5,4,4,3,2]).good_cells(1)
(2, 3)
sage: KP4 = KleshchevPartitions(4, convention='restricted')
sage: KP4([5,4,4,3,2]).good_cells()
{1: (2, 3)}
sage: KP4([5,4,4,3,2]).good_cells(0)
sage: KP4([5,4,4,3,2]).good_cells(1)
(2, 3)

Python

>>> from sage.all import *
>>> KP3 = KleshchevPartitions(Integer(3), convention='regular')
>>> KP3([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_cells()
{1: (2, 3)}
>>> KP3([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_cells(Integer(1))
(2, 3)
>>> KP4 = KleshchevPartitions(Integer(4), convention='restricted')
>>> KP4([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_cells()
{1: (2, 3)}
>>> KP4([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_cells(Integer(0))
>>> KP4([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_cells(Integer(1))
(2, 3)

Sage Live

KP3 = KleshchevPartitions(3, convention='regular')
KP3([5,4,4,3,2]).good_cells()
KP3([5,4,4,3,2]).good_cells(1)
KP4 = KleshchevPartitions(4, convention='restricted')
KP4([5,4,4,3,2]).good_cells()
KP4([5,4,4,3,2]).good_cells(0)
KP4([5,4,4,3,2]).good_cells(1)

good_residue_sequence()

Return a sequence of good nodes from the empty partition to self, or None if no such sequence exists.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, convention='regular')
sage: KP([5,4,4,3,2]).good_residue_sequence()
[0, 2, 1, 1, 0, 2, 0, 2, 1, 1, 0, 2, 0, 2, 2, 0, 1, 1]
sage: KP = KleshchevPartitions(3, convention='restricted')
sage: KP([5,4,4,3,2]).good_residue_sequence()
[0, 1, 2, 2, 0, 1, 0, 2, 1, 2, 0, 1, 0, 2, 1, 2, 1, 0]

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), convention='regular')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_residue_sequence()
[0, 2, 1, 1, 0, 2, 0, 2, 1, 1, 0, 2, 0, 2, 2, 0, 1, 1]
>>> KP = KleshchevPartitions(Integer(3), convention='restricted')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).good_residue_sequence()
[0, 1, 2, 2, 0, 1, 0, 2, 1, 2, 0, 1, 0, 2, 1, 2, 1, 0]

Sage Live

KP = KleshchevPartitions(3, convention='regular')
KP([5,4,4,3,2]).good_residue_sequence()
KP = KleshchevPartitions(3, convention='restricted')
KP([5,4,4,3,2]).good_residue_sequence()

is_regular()

Return True if self is a \(e\)-regular partition tuple.

A partition tuple is \(e\)-regular if we can get to the empty partition tuple by successively removing a sequence of good cells in the down direction. Equivalently, all partitions are \(0\)-regular and if \(e > 0\) then a partition is \(e\)-regular if no \(e\) nonzero parts of self are equal.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(2)
sage: KP([2,1,1]).is_regular()
False
sage: KP = KleshchevPartitions(3)
sage: KP([2,1,1]).is_regular()
True
sage: KP([]).is_regular()
True

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(2))
>>> KP([Integer(2),Integer(1),Integer(1)]).is_regular()
False
>>> KP = KleshchevPartitions(Integer(3))
>>> KP([Integer(2),Integer(1),Integer(1)]).is_regular()
True
>>> KP([]).is_regular()
True

Sage Live

KP = KleshchevPartitions(2)
KP([2,1,1]).is_regular()
KP = KleshchevPartitions(3)
KP([2,1,1]).is_regular()
KP([]).is_regular()

is_restricted()

Return True if self is an \(e\)-restricted partition tuple.

A partition tuple is \(e\)-restricted if we can get to the empty partition tuple by successively removing a sequence of good cells in the up direction. Equivalently, all partitions are \(0\)-restricted and if \(e > 0\) then a partition is \(e\)-restricted if the difference of successive parts of self are always strictly less than \(e\).

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(2, convention='regular')
sage: KP([3,1]).is_restricted()
False
sage: KP = KleshchevPartitions(3, convention='regular')
sage: KP([3,1]).is_restricted()
True
sage: KP([]).is_restricted()
True

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(2), convention='regular')
>>> KP([Integer(3),Integer(1)]).is_restricted()
False
>>> KP = KleshchevPartitions(Integer(3), convention='regular')
>>> KP([Integer(3),Integer(1)]).is_restricted()
True
>>> KP([]).is_restricted()
True

Sage Live

KP = KleshchevPartitions(2, convention='regular')
KP([3,1]).is_restricted()
KP = KleshchevPartitions(3, convention='regular')
KP([3,1]).is_restricted()
KP([]).is_restricted()

mullineux_conjugate()

Return the partition tuple that is the Mullineux conjugate of self.

It follows from results in [BK2009], [Mat2015] that if \(\nu\) is the Mullineux conjugate of the Kleshchev partition tuple \(\mu\) then the simple module \(D^\nu =(D^\mu)^{\text{sgn}}\) is obtained from \(D^\mu\) by twisting by the \(\text{sgn}\)-automorphism with is the Iwahori-Hecke algebra analogue of tensoring with the one dimensional sign representation.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, convention='regular')
sage: KP([5,4,4,3,2]).mullineux_conjugate()
[9, 7, 1, 1]
sage: KP = KleshchevPartitions(3, convention='restricted')
sage: KP([5,4,4,3,2]).mullineux_conjugate()
[3, 2, 2, 2, 2, 2, 2, 1, 1, 1]
sage: KP = KleshchevPartitions(3, [2], convention='regular')
sage: mc = KP([5,4,4,3,2]).mullineux_conjugate(); mc
[9, 7, 1, 1]
sage: mc.parent().multicharge()
(1,)
sage: KP = KleshchevPartitions(3, [2], convention='restricted')
sage: mc = KP([5,4,4,3,2]).mullineux_conjugate(); mc
[3, 2, 2, 2, 2, 2, 2, 1, 1, 1]
sage: mc.parent().multicharge()
(1,)

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), convention='regular')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).mullineux_conjugate()
[9, 7, 1, 1]
>>> KP = KleshchevPartitions(Integer(3), convention='restricted')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).mullineux_conjugate()
[3, 2, 2, 2, 2, 2, 2, 1, 1, 1]
>>> KP = KleshchevPartitions(Integer(3), [Integer(2)], convention='regular')
>>> mc = KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).mullineux_conjugate(); mc
[9, 7, 1, 1]
>>> mc.parent().multicharge()
(1,)
>>> KP = KleshchevPartitions(Integer(3), [Integer(2)], convention='restricted')
>>> mc = KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).mullineux_conjugate(); mc
[3, 2, 2, 2, 2, 2, 2, 1, 1, 1]
>>> mc.parent().multicharge()
(1,)

Sage Live

KP = KleshchevPartitions(3, convention='regular')
KP([5,4,4,3,2]).mullineux_conjugate()
KP = KleshchevPartitions(3, convention='restricted')
KP([5,4,4,3,2]).mullineux_conjugate()
KP = KleshchevPartitions(3, [2], convention='regular')
mc = KP([5,4,4,3,2]).mullineux_conjugate(); mc
mc.parent().multicharge()
KP = KleshchevPartitions(3, [2], convention='restricted')
mc = KP([5,4,4,3,2]).mullineux_conjugate(); mc
mc.parent().multicharge()

normal_cells(i=None)

Return a dictionary of the cells of the partition that are normal.

Following [Kle1995], the normal cells are computed by reading up (or down) the rows of the partition and marking all of the addable and removable cells of \(e\)-residue \(i\) and then recursively removing all adjacent pairs of removable and addable cells (in that order) from this list. The removable \(i\)-cells that remain at the end of the this process are the normal \(i\)-cells.

When computing normal cells you can either read the cells in order from top to bottom (this corresponds to labeling the simple modules of the symmetric group by regular partitions) or from bottom to top (corresponding to labeling the simples by restricted partitions). By default we read down the partition but this can be changed by setting convention = 'RS'.

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of normal cells is returned, which gives the normal cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, convention='regular')
sage: KP([5,4,4,3,2]).normal_cells()
{1: [(2, 3), (0, 4)]}
sage: KP([5,4,4,3,2]).normal_cells(1)
[(2, 3), (0, 4)]
sage: KP = KleshchevPartitions(3, convention='restricted')
sage: KP([5,4,4,3,2]).normal_cells()
{0: [(4, 1)], 2: [(3, 2)]}
sage: KP([5,4,4,3,2]).normal_cells(2)
[(3, 2)]

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), convention='regular')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).normal_cells()
{1: [(2, 3), (0, 4)]}
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).normal_cells(Integer(1))
[(2, 3), (0, 4)]
>>> KP = KleshchevPartitions(Integer(3), convention='restricted')
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).normal_cells()
{0: [(4, 1)], 2: [(3, 2)]}
>>> KP([Integer(5),Integer(4),Integer(4),Integer(3),Integer(2)]).normal_cells(Integer(2))
[(3, 2)]

Sage Live

KP = KleshchevPartitions(3, convention='regular')
KP([5,4,4,3,2]).normal_cells()
KP([5,4,4,3,2]).normal_cells(1)
KP = KleshchevPartitions(3, convention='restricted')
KP([5,4,4,3,2]).normal_cells()
KP([5,4,4,3,2]).normal_cells(2)

class sage.combinat.partition_kleshchev.KleshchevPartitionCrystal(parent, mu)

Bases: KleshchevPartition, KleshchevCrystalMixin

Kleshchev partition with the crystal structure.

e(i)

Return the action of \(e_i\) on self.

INPUT:

• i – an element of the index set

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, convention="left regular")
sage: x = C([5,4,1])
sage: x.e(0)
sage: x.e(1)
[5, 4]

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), convention="left regular")
>>> x = C([Integer(5),Integer(4),Integer(1)])
>>> x.e(Integer(0))
>>> x.e(Integer(1))
[5, 4]

Sage Live

C = crystals.KleshchevPartitions(3, convention="left regular")
x = C([5,4,1])
x.e(0)
x.e(1)

f(i)

Return the action of \(f_i\) on self.

INPUT:

• i – an element of the index set

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, convention="left regular")
sage: x = C([5,4,1])
sage: x.f(0)
[5, 5, 1]
sage: x.f(1)
sage: x.f(2)
[5, 4, 2]

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), convention="left regular")
>>> x = C([Integer(5),Integer(4),Integer(1)])
>>> x.f(Integer(0))
[5, 5, 1]
>>> x.f(Integer(1))
>>> x.f(Integer(2))
[5, 4, 2]

Sage Live

C = crystals.KleshchevPartitions(3, convention="left regular")
x = C([5,4,1])
x.f(0)
x.f(1)
x.f(2)

class sage.combinat.partition_kleshchev.KleshchevPartitionTuple(parent, mu)

Bases: PartitionTuple

Abstract base class for Kleshchev partition tuples. See KleshchevPartitions.

cogood_cells(i=None)

Return a list of the cells of the partition that are cogood.

The cogood \(i\)-cell is the ‘last’ conormal \(i\)-cell. As with the conormal cells we can choose to read either up or down the partition as specified by convention().

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of cogood cells is returned, which gives the cogood cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, [0,1])
sage: pt = KP([[4, 2], [5, 3, 1]])
sage: pt.cogood_cells()
{0: (1, 2, 1), 1: (1, 3, 0)}
sage: pt.cogood_cells(0)
(1, 2, 1)
sage: KP = KleshchevPartitions(4, [0,1], convention="left regular")
sage: pt = KP([[5, 2, 2], [6, 1, 1]])
sage: pt.cogood_cells()
{1: (0, 0, 5), 2: (1, 3, 0)}
sage: pt.cogood_cells(0) is None
True
sage: pt.cogood_cells(1) is None
False

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)])
>>> pt = KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]])
>>> pt.cogood_cells()
{0: (1, 2, 1), 1: (1, 3, 0)}
>>> pt.cogood_cells(Integer(0))
(1, 2, 1)
>>> KP = KleshchevPartitions(Integer(4), [Integer(0),Integer(1)], convention="left regular")
>>> pt = KP([[Integer(5), Integer(2), Integer(2)], [Integer(6), Integer(1), Integer(1)]])
>>> pt.cogood_cells()
{1: (0, 0, 5), 2: (1, 3, 0)}
>>> pt.cogood_cells(Integer(0)) is None
True
>>> pt.cogood_cells(Integer(1)) is None
False

Sage Live

KP = KleshchevPartitions(3, [0,1])
pt = KP([[4, 2], [5, 3, 1]])
pt.cogood_cells()
pt.cogood_cells(0)
KP = KleshchevPartitions(4, [0,1], convention="left regular")
pt = KP([[5, 2, 2], [6, 1, 1]])
pt.cogood_cells()
pt.cogood_cells(0) is None
pt.cogood_cells(1) is None

conormal_cells(i=None)

Return a dictionary of the cells of the partition that are conormal.

Following [Kle1995], the conormal cells are computed by reading up (or down) the rows of the partition and marking all of the addable and removable cells of \(e\)-residue \(i\) and then recursively removing all adjacent pairs of removable and addable cells (in that order) from this list. The addable \(i\)-cells that remain at the end of the this process are the conormal \(i\)-cells.

When computing conormal cells you can either read the cells in order from top to bottom (this corresponds to labeling the simple modules of the symmetric group by regular partitions) or from bottom to top (corresponding to labeling the simples by restricted partitions). By default we read down the partition but this can be changed by setting convention = 'RS'.

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of conormal cells is returned, which gives the conormal cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, [0,1], convention="left regular")
sage: KP([[4, 2], [5, 3, 1]]).conormal_cells()
{0: [(1, 2, 1), (1, 1, 3), (1, 0, 5)],
1: [(1, 3, 0), (0, 2, 0), (0, 1, 2), (0, 0, 4)]}
sage: KP([[4, 2], [5, 3, 1]]).conormal_cells(1)
[(1, 3, 0), (0, 2, 0), (0, 1, 2), (0, 0, 4)]
sage: KP([[4, 2], [5, 3, 1]]).conormal_cells(2)
[]
sage: KP = KleshchevPartitions(3, [0,1], convention="right restricted")
sage: KP([[4, 2], [5, 3, 1]]).conormal_cells(0)
[(1, 0, 5), (1, 1, 3), (1, 2, 1)]

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)], convention="left regular")
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).conormal_cells()
{0: [(1, 2, 1), (1, 1, 3), (1, 0, 5)],
1: [(1, 3, 0), (0, 2, 0), (0, 1, 2), (0, 0, 4)]}
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).conormal_cells(Integer(1))
[(1, 3, 0), (0, 2, 0), (0, 1, 2), (0, 0, 4)]
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).conormal_cells(Integer(2))
[]
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)], convention="right restricted")
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).conormal_cells(Integer(0))
[(1, 0, 5), (1, 1, 3), (1, 2, 1)]

Sage Live

KP = KleshchevPartitions(3, [0,1], convention="left regular")
KP([[4, 2], [5, 3, 1]]).conormal_cells()
KP([[4, 2], [5, 3, 1]]).conormal_cells(1)
KP([[4, 2], [5, 3, 1]]).conormal_cells(2)
KP = KleshchevPartitions(3, [0,1], convention="right restricted")
KP([[4, 2], [5, 3, 1]]).conormal_cells(0)

good_cell_sequence()

Return a sequence of good nodes from the empty partition to self.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3,[0,1])
sage: KP([[4, 2], [5, 3, 1]]).good_cell_sequence()
[(0, 0, 0), (1, 0, 0), (1, 0, 1), (0, 0, 1), (0, 1, 0),
 (1, 1, 0), (1, 1, 1), (1, 0, 2), (1, 2, 0), (0, 0, 2),
 (0, 1, 1), (1, 0, 3), (0, 0, 3), (1, 1, 2), (1, 0, 4)]

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3),[Integer(0),Integer(1)])
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).good_cell_sequence()
[(0, 0, 0), (1, 0, 0), (1, 0, 1), (0, 0, 1), (0, 1, 0),
 (1, 1, 0), (1, 1, 1), (1, 0, 2), (1, 2, 0), (0, 0, 2),
 (0, 1, 1), (1, 0, 3), (0, 0, 3), (1, 1, 2), (1, 0, 4)]

Sage Live

KP = KleshchevPartitions(3,[0,1])
KP([[4, 2], [5, 3, 1]]).good_cell_sequence()

good_cells(i=None)

Return a list of the cells of the partition tuple which are good.

The good \(i\)-cell is the ‘first’ normal \(i\)-cell. As with the normal cells we can choose to read either up or down the partition as specified by convention().

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of good cells is returned, which gives the good cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, [0,1])
sage: pt = KP([[4, 2], [5, 3, 1]])
sage: pt.good_cells()
{2: (1, 0, 4)}
sage: pt.good_cells(2)
(1, 0, 4)
sage: KP = KleshchevPartitions(4, [0,1], convention="left regular")
sage: pt = KP([[5, 2, 2], [6, 2, 1]])
sage: pt.good_cells()
{0: (0, 0, 4), 2: (1, 0, 5), 3: (0, 2, 1)}
sage: pt.good_cells(1) is None
True

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)])
>>> pt = KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]])
>>> pt.good_cells()
{2: (1, 0, 4)}
>>> pt.good_cells(Integer(2))
(1, 0, 4)
>>> KP = KleshchevPartitions(Integer(4), [Integer(0),Integer(1)], convention="left regular")
>>> pt = KP([[Integer(5), Integer(2), Integer(2)], [Integer(6), Integer(2), Integer(1)]])
>>> pt.good_cells()
{0: (0, 0, 4), 2: (1, 0, 5), 3: (0, 2, 1)}
>>> pt.good_cells(Integer(1)) is None
True

Sage Live

KP = KleshchevPartitions(3, [0,1])
pt = KP([[4, 2], [5, 3, 1]])
pt.good_cells()
pt.good_cells(2)
KP = KleshchevPartitions(4, [0,1], convention="left regular")
pt = KP([[5, 2, 2], [6, 2, 1]])
pt.good_cells()
pt.good_cells(1) is None

good_residue_sequence()

Return a sequence of good nodes from the empty partition to self.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, [0,1])
sage: KP([[4, 2], [5, 3, 1]]).good_residue_sequence()
[0, 1, 2, 1, 2, 0, 1, 0, 2, 2, 0, 1, 0, 2, 2]

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)])
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).good_residue_sequence()
[0, 1, 2, 1, 2, 0, 1, 0, 2, 2, 0, 1, 0, 2, 2]

Sage Live

KP = KleshchevPartitions(3, [0,1])
KP([[4, 2], [5, 3, 1]]).good_residue_sequence()

is_regular()

Return True if self is a \(e\)-regular partition tuple.

A partition tuple is \(e\)-regular if we can get to the empty partition tuple by successively removing a sequence of good cells in the down direction.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(2, [0,2], convention="right restricted")
sage: KP([[3,2,1], [2,1,1]]).is_regular()
False
sage: KP = KleshchevPartitions(4, [0,2], convention="right restricted")
sage: KP([[3,2,1], [2,1,1]]).is_regular()
True
sage: KP([[], []]).is_regular()
True

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(2), [Integer(0),Integer(2)], convention="right restricted")
>>> KP([[Integer(3),Integer(2),Integer(1)], [Integer(2),Integer(1),Integer(1)]]).is_regular()
False
>>> KP = KleshchevPartitions(Integer(4), [Integer(0),Integer(2)], convention="right restricted")
>>> KP([[Integer(3),Integer(2),Integer(1)], [Integer(2),Integer(1),Integer(1)]]).is_regular()
True
>>> KP([[], []]).is_regular()
True

Sage Live

KP = KleshchevPartitions(2, [0,2], convention="right restricted")
KP([[3,2,1], [2,1,1]]).is_regular()
KP = KleshchevPartitions(4, [0,2], convention="right restricted")
KP([[3,2,1], [2,1,1]]).is_regular()
KP([[], []]).is_regular()

is_restricted()

Return True if self is an \(e\)-restricted partition tuple.

A partition tuple is \(e\)-restricted if we can get to the empty partition tuple by successively removing a sequence of good cells in the up direction.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(2, [0,2], convention="left regular")
sage: KP([[3,2,1], [3,1]]).is_restricted()
False
sage: KP = KleshchevPartitions(3, [0,2], convention="left regular")
sage: KP([[3,2,1], [3,1]]).is_restricted()
True
sage: KP([[], []]).is_restricted()
True

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(2), [Integer(0),Integer(2)], convention="left regular")
>>> KP([[Integer(3),Integer(2),Integer(1)], [Integer(3),Integer(1)]]).is_restricted()
False
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> KP([[Integer(3),Integer(2),Integer(1)], [Integer(3),Integer(1)]]).is_restricted()
True
>>> KP([[], []]).is_restricted()
True

Sage Live

KP = KleshchevPartitions(2, [0,2], convention="left regular")
KP([[3,2,1], [3,1]]).is_restricted()
KP = KleshchevPartitions(3, [0,2], convention="left regular")
KP([[3,2,1], [3,1]]).is_restricted()
KP([[], []]).is_restricted()

mullineux_conjugate()

Return the partition that is the Mullineux conjugate of self.

It follows from results in [Kle1996] [Bru1998] that if \(\nu\) is the Mullineux conjugate of the Kleshchev partition tuple \(\mu\) then the simple module \(D^\nu =(D^\mu)^{\text{sgn}}\) is obtained from \(D^\mu\) by twisting by the \(\text{sgn}\)-automorphism with is the Hecke algebra analogue of tensoring with the one dimensional sign representation.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, [0,1])
sage: mc = KP([[4, 2], [5, 3, 1]]).mullineux_conjugate(); mc
([2, 2, 1, 1], [3, 2, 2, 1, 1])
sage: mc.parent()
Kleshchev partitions with e=3 and multicharge=(0,2)

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)])
>>> mc = KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).mullineux_conjugate(); mc
([2, 2, 1, 1], [3, 2, 2, 1, 1])
>>> mc.parent()
Kleshchev partitions with e=3 and multicharge=(0,2)

Sage Live

KP = KleshchevPartitions(3, [0,1])
mc = KP([[4, 2], [5, 3, 1]]).mullineux_conjugate(); mc
mc.parent()

normal_cells(i=None)

Return a dictionary of the removable cells of the partition that are normal.

Following [Kle1995], the normal cells are computed by reading up (or down) the rows of the partition and marking all of the addable and removable cells of \(e\)-residue \(i\) and then recursively removing all adjacent pairs of removable and addable cells (in that order) from this list. The removable \(i\)-cells that remain at the end of the this process are the normal \(i\)-cells.

When computing normal cells you can either read the cells in order from top to bottom (this corresponds to labeling the simple modules of the symmetric group by regular partitions) or from bottom to top (corresponding to labeling the simples by restricted partitions). By default we read down the partition but this can be changed by setting convention = 'RS'.

INPUT:

• i – (optional) a residue

OUTPUT:

If no residue i is specified then a dictionary of normal cells is returned, which gives the normal cells for 0 <= i < e.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(3, [0,1], convention="left restricted")
sage: KP([[4, 2], [5, 3, 1]]).normal_cells()
{2: [(1, 0, 4), (1, 1, 2), (1, 2, 0)]}
sage: KP([[4, 2], [5, 3, 1]]).normal_cells(1)
[]
sage: KP = KleshchevPartitions(3, [0,1], convention="left regular")
sage: KP([[4, 2], [5, 3, 1]]).normal_cells()
{0: [(0, 1, 1), (0, 0, 3)], 2: [(1, 2, 0), (1, 1, 2), (1, 0, 4)]}
sage: KP = KleshchevPartitions(3, [0,1], convention="right regular")
sage: KP([[4, 2], [5, 3, 1]]).normal_cells()
{2: [(1, 2, 0), (1, 1, 2), (1, 0, 4)]}
sage: KP = KleshchevPartitions(3, [0,1], convention="right restricted")
sage: KP([[4, 2], [5, 3, 1]]).normal_cells()
{0: [(0, 0, 3), (0, 1, 1)], 2: [(1, 0, 4), (1, 1, 2), (1, 2, 0)]}

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)], convention="left restricted")
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).normal_cells()
{2: [(1, 0, 4), (1, 1, 2), (1, 2, 0)]}
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).normal_cells(Integer(1))
[]
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)], convention="left regular")
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).normal_cells()
{0: [(0, 1, 1), (0, 0, 3)], 2: [(1, 2, 0), (1, 1, 2), (1, 0, 4)]}
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)], convention="right regular")
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).normal_cells()
{2: [(1, 2, 0), (1, 1, 2), (1, 0, 4)]}
>>> KP = KleshchevPartitions(Integer(3), [Integer(0),Integer(1)], convention="right restricted")
>>> KP([[Integer(4), Integer(2)], [Integer(5), Integer(3), Integer(1)]]).normal_cells()
{0: [(0, 0, 3), (0, 1, 1)], 2: [(1, 0, 4), (1, 1, 2), (1, 2, 0)]}

Sage Live

KP = KleshchevPartitions(3, [0,1], convention="left restricted")
KP([[4, 2], [5, 3, 1]]).normal_cells()
KP([[4, 2], [5, 3, 1]]).normal_cells(1)
KP = KleshchevPartitions(3, [0,1], convention="left regular")
KP([[4, 2], [5, 3, 1]]).normal_cells()
KP = KleshchevPartitions(3, [0,1], convention="right regular")
KP([[4, 2], [5, 3, 1]]).normal_cells()
KP = KleshchevPartitions(3, [0,1], convention="right restricted")
KP([[4, 2], [5, 3, 1]]).normal_cells()

class sage.combinat.partition_kleshchev.KleshchevPartitionTupleCrystal(parent, mu)

Bases: KleshchevPartitionTuple, KleshchevCrystalMixin

Kleshchev partition tuple with the crystal structure.

e(i)

Return the action of \(e_i\) on self.

INPUT:

• i – an element of the index set

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: x = C([[5,4,1],[3,2,1,1]])
sage: x.e(0)
sage: x.e(1)
([5, 4, 1], [2, 2, 1, 1])

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> x = C([[Integer(5),Integer(4),Integer(1)],[Integer(3),Integer(2),Integer(1),Integer(1)]])
>>> x.e(Integer(0))
>>> x.e(Integer(1))
([5, 4, 1], [2, 2, 1, 1])

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
x = C([[5,4,1],[3,2,1,1]])
x.e(0)
x.e(1)

f(i)

Return the action of \(f_i\) on self.

INPUT:

• i – an element of the index set

EXAMPLES:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
sage: x = C([[5,4,1],[3,2,1,1]])
sage: x.f(0)
([5, 5, 1], [3, 2, 1, 1])
sage: x.f(1)
([5, 4, 1], [3, 2, 2, 1])
sage: x.f(2)

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="left regular")
>>> x = C([[Integer(5),Integer(4),Integer(1)],[Integer(3),Integer(2),Integer(1),Integer(1)]])
>>> x.f(Integer(0))
([5, 5, 1], [3, 2, 1, 1])
>>> x.f(Integer(1))
([5, 4, 1], [3, 2, 2, 1])
>>> x.f(Integer(2))

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="left regular")
x = C([[5,4,1],[3,2,1,1]])
x.f(0)
x.f(1)
x.f(2)

class sage.combinat.partition_kleshchev.KleshchevPartitions

Bases: PartitionTuples

Kleshchev partitions.

A partition (tuple) \(\mu\) is Kleshchev if it can be recursively obtained by adding a sequence of good nodes to the empty PartitionTuple of the same level() and multicharge.

There are four different conventions that are used in the literature for Kleshchev partitions, depending on whether we read partitions from top to bottom (regular) or bottom to top (restricted) and whether we read partition tuples from left to right or right to left. All of these conventions are supported:

Sage

sage: KleshchevPartitions(2, [0,0], size=2, convention='left regular')[:]
[([1], [1]), ([2], [])]
sage: KleshchevPartitions(2, [0,0], size=2, convention='left restricted')[:]
[([1], [1]), ([], [1, 1])]
sage: KleshchevPartitions(2, [0,0], size=2, convention='right regular')[:]
[([1], [1]), ([], [2])]
sage: KleshchevPartitions(2, [0,0], size=2, convention='right restricted')[:]
[([1], [1]), ([1, 1], [])]

Python

>>> from sage.all import *
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left regular')[:]
[([1], [1]), ([2], [])]
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left restricted')[:]
[([1], [1]), ([], [1, 1])]
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='right regular')[:]
[([1], [1]), ([], [2])]
>>> KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='right restricted')[:]
[([1], [1]), ([1, 1], [])]

Sage Live

KleshchevPartitions(2, [0,0], size=2, convention='left regular')[:]
KleshchevPartitions(2, [0,0], size=2, convention='left restricted')[:]
KleshchevPartitions(2, [0,0], size=2, convention='right regular')[:]
KleshchevPartitions(2, [0,0], size=2, convention='right restricted')[:]

By default, the left restricted convention is used. As a shorthand, LG, LS, RG and RS, respectively, can be used to specify the convention. With the left convention the partition tuples should be ordered with the most dominant partitions in the partition tuple on the left and with the right convention the most dominant partition is on the right.

The KleshchevPartitions class will automatically convert between these four different conventions:

Sage

sage: KPlg = KleshchevPartitions(2, [0,0], size=2, convention='left regular')
sage: KPls = KleshchevPartitions(2, [0,0], size=2, convention='left restricted')
sage: [KPlg(mu) for mu in KPls]
[([1], [1]), ([2], [])]

Python

>>> from sage.all import *
>>> KPlg = KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left regular')
>>> KPls = KleshchevPartitions(Integer(2), [Integer(0),Integer(0)], size=Integer(2), convention='left restricted')
>>> [KPlg(mu) for mu in KPls]
[([1], [1]), ([2], [])]

Sage Live

KPlg = KleshchevPartitions(2, [0,0], size=2, convention='left regular')
KPls = KleshchevPartitions(2, [0,0], size=2, convention='left restricted')
[KPlg(mu) for mu in KPls]

EXAMPLES:

Sage

sage: sorted(KleshchevPartitions(5,[3,2,1],1, convention='RS'))
[([], [], [1]), ([], [1], []), ([1], [], [])]
sage: sorted(KleshchevPartitions(5, [3,2,1], 1, convention='LS'))
[([], [], [1]), ([], [1], []), ([1], [], [])]
sage: sorted(KleshchevPartitions(5, [3,2,1], 3))
[([], [], [1, 1, 1]),
 ([], [], [2, 1]),
 ([], [], [3]),
 ([], [1], [1, 1]),
 ([], [1], [2]),
 ([], [1, 1], [1]),
 ([], [2], [1]),
 ([], [3], []),
 ([1], [], [1, 1]),
 ([1], [], [2]),
 ([1], [1], [1]),
 ([1], [2], []),
 ([1, 1], [1], []),
 ([2], [], [1]),
 ([2], [1], []),
 ([3], [], [])]
sage: sorted(KleshchevPartitions(5, [3,2,1], 3, convention="left regular"))
[([], [], [1, 1, 1]),
 ([], [1], [1, 1]),
 ([], [1], [2]),
 ([], [1, 1], [1]),
 ([], [1, 1, 1], []),
 ([1], [], [1, 1]),
 ([1], [1], [1]),
 ([1], [1, 1], []),
 ([1], [2], []),
 ([1, 1], [], [1]),
 ([1, 1], [1], []),
 ([1, 1, 1], [], []),
 ([2], [], [1]),
 ([2], [1], []),
 ([2, 1], [], []),
 ([3], [], [])]

Python

>>> from sage.all import *
>>> sorted(KleshchevPartitions(Integer(5),[Integer(3),Integer(2),Integer(1)],Integer(1), convention='RS'))
[([], [], [1]), ([], [1], []), ([1], [], [])]
>>> sorted(KleshchevPartitions(Integer(5), [Integer(3),Integer(2),Integer(1)], Integer(1), convention='LS'))
[([], [], [1]), ([], [1], []), ([1], [], [])]
>>> sorted(KleshchevPartitions(Integer(5), [Integer(3),Integer(2),Integer(1)], Integer(3)))
[([], [], [1, 1, 1]),
 ([], [], [2, 1]),
 ([], [], [3]),
 ([], [1], [1, 1]),
 ([], [1], [2]),
 ([], [1, 1], [1]),
 ([], [2], [1]),
 ([], [3], []),
 ([1], [], [1, 1]),
 ([1], [], [2]),
 ([1], [1], [1]),
 ([1], [2], []),
 ([1, 1], [1], []),
 ([2], [], [1]),
 ([2], [1], []),
 ([3], [], [])]
>>> sorted(KleshchevPartitions(Integer(5), [Integer(3),Integer(2),Integer(1)], Integer(3), convention="left regular"))
[([], [], [1, 1, 1]),
 ([], [1], [1, 1]),
 ([], [1], [2]),
 ([], [1, 1], [1]),
 ([], [1, 1, 1], []),
 ([1], [], [1, 1]),
 ([1], [1], [1]),
 ([1], [1, 1], []),
 ([1], [2], []),
 ([1, 1], [], [1]),
 ([1, 1], [1], []),
 ([1, 1, 1], [], []),
 ([2], [], [1]),
 ([2], [1], []),
 ([2, 1], [], []),
 ([3], [], [])]

Sage Live

sorted(KleshchevPartitions(5,[3,2,1],1, convention='RS'))
sorted(KleshchevPartitions(5, [3,2,1], 1, convention='LS'))
sorted(KleshchevPartitions(5, [3,2,1], 3))
sorted(KleshchevPartitions(5, [3,2,1], 3, convention="left regular"))

REFERENCES:

• [AM2000]

• [Ariki2001]

• [BK2009]

• [Kle2009]

convention()

Return the convention of self.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(4)
sage: KP.convention()
'restricted'
sage: KP = KleshchevPartitions(6, [4], 3, convention="right regular")
sage: KP.convention()
'regular'
sage: KP = KleshchevPartitions(5, [3,0,1], 1)
sage: KP.convention()
'left restricted'
sage: KP = KleshchevPartitions(5, [3,0,1], 1, convention='right regular')
sage: KP.convention()
'right regular'

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(4))
>>> KP.convention()
'restricted'
>>> KP = KleshchevPartitions(Integer(6), [Integer(4)], Integer(3), convention="right regular")
>>> KP.convention()
'regular'
>>> KP = KleshchevPartitions(Integer(5), [Integer(3),Integer(0),Integer(1)], Integer(1))
>>> KP.convention()
'left restricted'
>>> KP = KleshchevPartitions(Integer(5), [Integer(3),Integer(0),Integer(1)], Integer(1), convention='right regular')
>>> KP.convention()
'right regular'

Sage Live

KP = KleshchevPartitions(4)
KP.convention()
KP = KleshchevPartitions(6, [4], 3, convention="right regular")
KP.convention()
KP = KleshchevPartitions(5, [3,0,1], 1)
KP.convention()
KP = KleshchevPartitions(5, [3,0,1], 1, convention='right regular')
KP.convention()

multicharge()

Return the multicharge of self.

EXAMPLES:

Sage

sage: KP = KleshchevPartitions(6, [2])
sage: KP.multicharge()
(2,)
sage: KP = KleshchevPartitions(5, [3,0,1], 1, convention='LS')
sage: KP.multicharge()
(3, 0, 1)

Python

>>> from sage.all import *
>>> KP = KleshchevPartitions(Integer(6), [Integer(2)])
>>> KP.multicharge()
(2,)
>>> KP = KleshchevPartitions(Integer(5), [Integer(3),Integer(0),Integer(1)], Integer(1), convention='LS')
>>> KP.multicharge()
(3, 0, 1)

Sage Live

KP = KleshchevPartitions(6, [2])
KP.multicharge()
KP = KleshchevPartitions(5, [3,0,1], 1, convention='LS')
KP.multicharge()

class sage.combinat.partition_kleshchev.KleshchevPartitions_all(e, multicharge, convention)

Bases: KleshchevPartitions

Class of all Kleshchev partitions.

Crystal structure

We consider type \(A_{e-1}^{(1)}\) crystals, and let \(r = (r_i | r_i \in \ZZ / e \ZZ)\) be a finite sequence of length \(k\), which is the level, and \(\lambda = \sum_i \Lambda_{r_i}\). We will model the highest weight \(U_q(\mathfrak{g})\)-crystal \(B(\lambda)\) by a particular subset of partition tuples of level \(k\).

Consider a partition tuple \(\mu\) with multicharge \(r\). We define \(e_i(\mu)\) as the partition tuple obtained after the deletion of the \(i\)-good cell to \(\mu\) and \(0\) if there is no \(i\)-good cell. We define \(f_i(\mu)\) as the partition tuple obtained by the addition of the \(i\)-cogood cell to \(\mu\) and \(0\) if there is no \(i\)-good cell.

The crystal \(B(\lambda)\) is the crystal generated by the empty partition tuple. We can compute the weight of an element \(\mu\) by taking \(\lambda - \sum_{i=0}^n c_i \alpha_i\) where \(c_i\) is the number of cells of \(n\)-residue \(i\) in \(\mu\). Partition tuples in the crystal are known as Kleshchev partitions.

Note

We can describe normal (not restricted) Kleshchev partition tuples in \(B(\lambda)\) as partition tuples \(\mu\) such that \(\mu^{(t)}_{r_t - r_{t+1} + x} < \mu^{(t+1)}_x\) for all \(x \geq 1\) and \(1 \leq t \leq k - 1\).

INPUT:

• e – for type \(A_{e-1}^{(1)}\) or \(0\)

• multicharge – the multicharge sequence \(r\)

• convention – (default: 'LS') the reading convention

EXAMPLES:

We first do an example of a level 1 crystal:

Sage

sage: C = crystals.KleshchevPartitions(3, [0], convention="left restricted")
sage: C
Kleshchev partitions with e=3
sage: mg = C.highest_weight_vector()
sage: mg
[]
sage: mg.f(0)
[1]
sage: mg.f(1)
sage: mg.f(2)
sage: mg.f_string([0,2,1,0])
[1, 1, 1, 1]
sage: mg.f_string([0,1,2,0])
[2, 2]
sage: GC = C.subcrystal(max_depth=5).digraph()
sage: B = crystals.LSPaths(['A',2,1], [1,0,0])
sage: GB = B.subcrystal(max_depth=5).digraph()
sage: GC.is_isomorphic(GB, edge_labels=True)
True

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0)], convention="left restricted")
>>> C
Kleshchev partitions with e=3
>>> mg = C.highest_weight_vector()
>>> mg
[]
>>> mg.f(Integer(0))
[1]
>>> mg.f(Integer(1))
>>> mg.f(Integer(2))
>>> mg.f_string([Integer(0),Integer(2),Integer(1),Integer(0)])
[1, 1, 1, 1]
>>> mg.f_string([Integer(0),Integer(1),Integer(2),Integer(0)])
[2, 2]
>>> GC = C.subcrystal(max_depth=Integer(5)).digraph()
>>> B = crystals.LSPaths(['A',Integer(2),Integer(1)], [Integer(1),Integer(0),Integer(0)])
>>> GB = B.subcrystal(max_depth=Integer(5)).digraph()
>>> GC.is_isomorphic(GB, edge_labels=True)
True

Sage Live

C = crystals.KleshchevPartitions(3, [0], convention="left restricted")
C
mg = C.highest_weight_vector()
mg
mg.f(0)
mg.f(1)
mg.f(2)
mg.f_string([0,2,1,0])
mg.f_string([0,1,2,0])
GC = C.subcrystal(max_depth=5).digraph()
B = crystals.LSPaths(['A',2,1], [1,0,0])
GB = B.subcrystal(max_depth=5).digraph()
GC.is_isomorphic(GB, edge_labels=True)

Now a higher level crystal:

Sage

sage: C = crystals.KleshchevPartitions(3, [0,2], convention="right restricted")
sage: mg = C.highest_weight_vector()
sage: mg
([], [])
sage: mg.f(0)
([1], [])
sage: mg.f(2)
([], [1])
sage: mg.f_string([0,1,2,0])
([2, 2], [])
sage: mg.f_string([0,2,1,0])
([1, 1, 1, 1], [])
sage: mg.f_string([2,0,1,0])
([2], [2])
sage: GC = C.subcrystal(max_depth=5).digraph()
sage: B = crystals.LSPaths(['A',2,1], [1,0,1])
sage: GB = B.subcrystal(max_depth=5).digraph()
sage: GC.is_isomorphic(GB, edge_labels=True)
True

Python

>>> from sage.all import *
>>> C = crystals.KleshchevPartitions(Integer(3), [Integer(0),Integer(2)], convention="right restricted")
>>> mg = C.highest_weight_vector()
>>> mg
([], [])
>>> mg.f(Integer(0))
([1], [])
>>> mg.f(Integer(2))
([], [1])
>>> mg.f_string([Integer(0),Integer(1),Integer(2),Integer(0)])
([2, 2], [])
>>> mg.f_string([Integer(0),Integer(2),Integer(1),Integer(0)])
([1, 1, 1, 1], [])
>>> mg.f_string([Integer(2),Integer(0),Integer(1),Integer(0)])
([2], [2])
>>> GC = C.subcrystal(max_depth=Integer(5)).digraph()
>>> B = crystals.LSPaths(['A',Integer(2),Integer(1)], [Integer(1),Integer(0),Integer(1)])
>>> GB = B.subcrystal(max_depth=Integer(5)).digraph()
>>> GC.is_isomorphic(GB, edge_labels=True)
True

Sage Live

C = crystals.KleshchevPartitions(3, [0,2], convention="right restricted")
mg = C.highest_weight_vector()
mg
mg.f(0)
mg.f(2)
mg.f_string([0,1,2,0])
mg.f_string([0,2,1,0])
mg.f_string([2,0,1,0])
GC = C.subcrystal(max_depth=5).digraph()
B = crystals.LSPaths(['A',2,1], [1,0,1])
GB = B.subcrystal(max_depth=5).digraph()
GC.is_isomorphic(GB, edge_labels=True)

The ordering of the residues gives a different representation of the higher level crystals (but it is still isomorphic):

Sage

sage: C2 = crystals.KleshchevPartitions(3, [2,0], convention="right restricted")
sage: mg2 = C2.highest_weight_vector()
sage: mg2.f_string([0,1,2,0])
([2], [2])
sage: mg2.f_string([0,2,1,0])
([1, 1, 1], [1])
sage: mg2.f_string([2,0,1,0])
([2, 1], [1])
sage: GC2 = C2.subcrystal(max_depth=5).digraph()
sage: GC.is_isomorphic(GC2, edge_labels=True)
True

Python

>>> from sage.all import *
>>> C2 = crystals.KleshchevPartitions(Integer(3), [Integer(2),Integer(0)], convention="right restricted")
>>> mg2 = C2.highest_weight_vector()
>>> mg2.f_string([Integer(0),Integer(1),Integer(2),Integer(0)])
([2], [2])
>>> mg2.f_string([Integer(0),Integer(2),Integer(1),Integer(0)])
([1, 1, 1], [1])
>>> mg2.f_string([Integer(2),Integer(0),Integer(1),Integer(0)])
([2, 1], [1])
>>> GC2 = C2.subcrystal(max_depth=Integer(5)).digraph()
>>> GC.is_isomorphic(GC2, edge_labels=True)
True

Sage Live

C2 = crystals.KleshchevPartitions(3, [2,0], convention="right restricted")
mg2 = C2.highest_weight_vector()
mg2.f_string([0,1,2,0])
mg2.f_string([0,2,1,0])
mg2.f_string([2,0,1,0])
GC2 = C2.subcrystal(max_depth=5).digraph()
GC.is_isomorphic(GC2, edge_labels=True)

REFERENCES:

• [Ariki1996]

• [Ariki2001]

• [Tingley2007]

• [TingleyLN]

• [Vazirani2002]

class sage.combinat.partition_kleshchev.KleshchevPartitions_size(e, multicharge=(0,), size=0, convention='RS')

Bases: KleshchevPartitions

Kleshchev partitions of a fixed size.

Element

alias of KleshchevPartitionTuple

Make live