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

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

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

Return \(\phi\) of self.

EXAMPLES:

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]
epsilon(i)

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

INPUT:

  • i – an element of the index set

EXAMPLES:

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]
phi(i)

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

INPUT:

  • i – an element of the index set

EXAMPLES:

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

Return the weight of self.

EXAMPLES:

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]
class sage.combinat.partition_kleshchev.KleshchevPartition(parent, mu)

Bases: sage.combinat.partition.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: 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)
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: 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)]}
good_cell_sequence()

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

EXAMPLES:

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

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

EXAMPLES:

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]
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\) non-zero parts of self are equal.

EXAMPLES:

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
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: 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
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: 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,)
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: 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)]
class sage.combinat.partition_kleshchev.KleshchevPartitionCrystal(parent, mu)

Bases: sage.combinat.partition_kleshchev.KleshchevPartition, sage.combinat.partition_kleshchev.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: C = crystals.KleshchevPartitions(3, convention="left regular")
sage: x = C([5,4,1])
sage: x.e(0)
sage: x.e(1)
[5, 4]
f(i)

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

INPUT:

  • i – an element of the index set

EXAMPLES:

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]
class sage.combinat.partition_kleshchev.KleshchevPartitionTuple(parent, mu)

Bases: sage.combinat.partition_tuple.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: 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
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: 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)]
good_cell_sequence()

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

EXAMPLES:

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

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

EXAMPLES:

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]
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: 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
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: 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
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: 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)
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: 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)]}
class sage.combinat.partition_kleshchev.KleshchevPartitionTupleCrystal(parent, mu)

Bases: sage.combinat.partition_kleshchev.KleshchevPartitionTuple, sage.combinat.partition_kleshchev.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: 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])
f(i)

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

INPUT:

  • i – an element of the index set

EXAMPLES:

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)
class sage.combinat.partition_kleshchev.KleshchevPartitions

Bases: sage.combinat.partition_tuple.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: 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], [])]

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

EXAMPLES:

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

REFERENCES:

convention()

Return the convention of self.

EXAMPLES:

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

Return the multicharge of self.

EXAMPLES:

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)
class sage.combinat.partition_kleshchev.KleshchevPartitions_all(e, multicharge, convention)

Bases: sage.combinat.partition_kleshchev.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: 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

Now a higher level crystal:

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

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

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

REFERENCES:

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

Bases: sage.combinat.partition_kleshchev.KleshchevPartitions

Kleshchev partitions of a fixed size.

Element

alias of KleshchevPartitionTuple