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 ArikiBrundanKleshchev 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 BrundanKleshchev 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 (2018051): 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 for0 <= 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 for0 <= 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
, orNone
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 for0 <= 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
, orNone
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
ifself
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: 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
ifself
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 IwahoriHecke 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 for0 <= 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 for0 <= 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 for0 <= 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 for0 <= 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
ifself
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
ifself
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 for0 <= 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 samelevel()
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
andRS
, respectively, can be used to specify theconvention
. With theleft
convention the partition tuples should be ordered with the most dominant partitions in the partition tuple on the left and with theright
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_{e1}^{(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_{e1}^{(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
