Kirillov-Reshetikhin Tableaux

Kirillov-Reshetikhin tableaux are rectangular tableaux with r rows and s columns that naturally arise under the bijection between rigged configurations and tableaux [RigConBijection]. They are in bijection with the elements of the Kirillov-Reshetikhin crystal B^{r,s} under the (inverse) filling map [OSS13] [SchScr]. They do not have to satisfy the semistandard row or column restrictions. These tensor products are the result from the bijection from rigged configurations [RigConBijection].

For more information, see KirillovReshetikhinTableaux and TensorProductOfKirillovReshetikhinTableaux.

AUTHORS:

  • Travis Scrimshaw (2012-01-03): Initial version
  • Travis Scrimshaw (2012-11-14): Added bijection to KR crystals

REFERENCES:

[OSS13]Masato Okado, Reiho Sakamoto, and Anne Schilling. Affine crystal structure on rigged configurations of type D_n^{(1)}. J. Algebraic Combinatorics, 37 (2013). 571-599. Arxiv 1109.3523.
class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxBn(cartan_type, r, s)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxTypeHorizonal

Kirillov-Reshetkhin tableaux B^{n,s} of type B_n^{(1)}.

TESTS:

sage: KRT = crystals.KirillovReshetikhin(['B', 2, 1], 2, 3, model='KR')
sage: TestSuite(KRT).run()
Element

alias of KRTableauxSpinElement

from_kirillov_reshetikhin_crystal(krc)

Construct an element of self from the Kirillov-Reshetikhin crystal element krc.

EXAMPLES:

sage: KR = crystals.KirillovReshetikhin(['B',3,1], 3, 3, model='KR')
sage: C = crystals.KirillovReshetikhin(['B',3,1], 3, 3, model='KN')
sage: krc = C.module_generators[1].f_string([3,2,3,1,3,3]); krc
[++-, [[2], [0], [-3]]]
sage: KR.from_kirillov_reshetikhin_crystal(krc)
[[1, 1, 2], [2, 2, -3], [-3, -3, -1]]
class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxDTwistedSpin(cartan_type, r, s)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxRectangle

Kirillov-Reshetikhin tableaux B^{r,s} of type D_n^{(2)} with r = n.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 2], 1, 1, model='KR')
sage: KRT.cardinality()
8
sage: KRC = crystals.KirillovReshetikhin(['D', 4, 2], 1, 1, model='KN')
sage: KRT.cardinality() == KRC.cardinality()
True
Element

alias of KRTableauxSpinElement

class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxRectangle(cartan_type, r, s)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableaux

Kirillov-Reshetkhin tableaux B^{r,s} whose module generator is a single r \times s rectangle.

These are Kirillov-Reshetkhin tableaux B^{r,s} of type:

  • A_n^{(1)} for all 1 \leq r \leq n,
  • C_n^{(1)} when r = n.

TESTS:

sage: KRT = crystals.KirillovReshetikhin(['A', 3, 1], 2, 2, model='KR')
sage: TestSuite(KRT).run()
sage: KRT = crystals.KirillovReshetikhin(['C', 3, 1], 3, 2, model='KR')
sage: TestSuite(KRT).run() # long time
from_kirillov_reshetikhin_crystal(krc)

Construct a KirillovReshetikhinTableauxElement.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 1, model='KR')
sage: C = crystals.KirillovReshetikhin(['A',4,1], 2, 1, model='KN')
sage: krc = C(4,3); krc
[[3], [4]]
sage: KRT.from_kirillov_reshetikhin_crystal(krc)
[[3], [4]]
class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxSpin(cartan_type, r, s)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxRectangle

Kirillov-Reshetikhin tableaux B^{r,s} of type D_n^{(1)} with r = n, n-1.

TESTS:

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 3, 2, model='KR')
sage: TestSuite(KRT).run()
sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 4, 2, model='KR')
sage: TestSuite(KRT).run()
Element

alias of KRTableauxSpinElement

class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxSpinElement(parent, list, **options)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableauxElement

Kirillov-Reshetikhin tableau for spinors.

Here we are in the embedding B(\Lambda_n) \hookrightarrow
B(2 \Lambda_n), so e_i and f_i act by e_i^2 and f_i^2 respectively for all i \neq 0. We do this so our columns are full width (as opposed to half width and/or uses a \pm representation).

e(i)

Calculate the action of e_i on self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 4, 1, model='KR')
sage: KRT(-1, -4, 3, 2).e(1)
[[1], [3], [-4], [-2]]
sage: KRT(-1, -4, 3, 2).e(3)
epsilon(i)

Compute \varepsilon_i of self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 4, 1, model='KR')
sage: KRT(-1, -4, 3, 2).epsilon(1)
1
sage: KRT(-1, -4, 3, 2).epsilon(3)
0
f(i)

Calculate the action of f_i on self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 4, 1, model='KR')
sage: KRT(-1, -4, 3, 2).f(1)
sage: KRT(-1, -4, 3, 2).f(3)
[[2], [4], [-3], [-1]]
left_split()

Return the image of self under the left column splitting map.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 4, 3, model='KR')
sage: elt = KRT(-3,-4,2,1,-3,-4,2,1,-2,-4,3,1); elt.pp()
  1  1  1
  2  2  3
 -4 -4 -4
 -3 -3 -2
sage: elt.left_split().pp()
  1 (X)   1  1
  2       2  3
 -4      -4 -4
 -3      -3 -2
phi(i)

Compute \varphi_i of self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 4, 1, model='KR')
sage: KRT(-1, -4, 3, 2).phi(1)
0
sage: KRT(-1, -4, 3, 2).phi(3)
1
to_array(rows=True)

Return a 2-dimensional array representation of this Kirillov-Reshetikhin element.

If the output is in rows, then it outputs the top row first (in the English convention) from left to right.

For example: if the reading word is [2, 1, 4, 3], so as a 2 \times 2 tableau:

1 3
2 4

we output [[1, 3], [2, 4]].

If the output is in columns, then it outputs the leftmost column first with the bottom element first. In other words this parses the reading word into its columns.

Continuing with the previous example, the output would be [[2, 1], [4, 3]].

INPUT:

  • rows – (Default: True) Set to True if the resulting array is by row, otherwise it is by column.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 4, 3, model='KR')
sage: elt = KRT(-3,-4,2,1,-3,-4,2,1,-2,-4,3,1)
sage: elt.to_array()
[[1, 1, 1], [2, 2, 3], [-4, -4, -4], [-3, -3, -2]]
sage: elt.to_array(False)
[[-3, -4, 2, 1], [-3, -4, 2, 1], [-2, -4, 3, 1]]
class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxTypeBox(cartan_type, r, s)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxTypeVertical

Kirillov-Reshetikhin tableaux B^{r,s} of type:

  • A_{2n}^{(2)} for all r \leq n,
  • D_{n+1}^{(2)} for all r < n.

TESTS:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 2], 2, 2, model='KR')
sage: TestSuite(KRT).run()
sage: KRT = crystals.KirillovReshetikhin(['D', 4, 2], 2, 2, model='KR')
sage: TestSuite(KRT).run() # long time
class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxTypeHorizonal(cartan_type, r, s)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableaux

Kirillov-Reshetikhin tableaux B^{r,s} of type:

  • C_n^{(1)} for 1 \leq r < n,
  • A_{2n}^{(2)\dagger} for 1 \leq r \leq n.

TESTS:

sage: KRT = crystals.KirillovReshetikhin(['C', 3, 1], 2, 2, model='KR')
sage: TestSuite(KRT).run() # long time
sage: KRT = crystals.KirillovReshetikhin(CartanType(['A', 4, 2]).dual(), 2, 2, model='KR')
sage: TestSuite(KRT).run()
from_kirillov_reshetikhin_crystal(krc)

Construct an element of self from the Kirillov-Reshetikhin crystal element krc.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['C',4,1], 2, 3, model='KR')
sage: C = crystals.KirillovReshetikhin(['C',4,1], 2, 3, model='KN')
sage: krc = C(4,3); krc
[[3], [4]]
sage: KRT.from_kirillov_reshetikhin_crystal(krc)
[[3, -2, 1], [4, -1, 2]]
class sage.combinat.rigged_configurations.kr_tableaux.KRTableauxTypeVertical(cartan_type, r, s)

Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableaux

Kirillov-Reshetkihn tableaux B^{r,s} of type:

  • D_n^{(1)} for all 1 \leq r < n-1,
  • B_n^{(1)} for all 1 \leq r < n,
  • A_{2n-1}^{(2)} for all 1 \leq r \leq n.

TESTS:

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 1, 1, model='KR')
sage: TestSuite(KRT).run()
sage: KRT = crystals.KirillovReshetikhin(['B', 3, 1], 2, 2, model='KR')
sage: TestSuite(KRT).run() # long time
sage: KRT = crystals.KirillovReshetikhin(['A', 5, 2], 2, 2, model='KR')
sage: TestSuite(KRT).run() # long time
from_kirillov_reshetikhin_crystal(krc)

Construct an element of self from the Kirillov-Reshetikhin crystal element krc.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 3, model='KR')
sage: C = crystals.KirillovReshetikhin(['D',4,1], 2, 3, model='KN')
sage: krc = C(4,3); krc
[[3], [4]]
sage: KRT.from_kirillov_reshetikhin_crystal(krc)
[[3, -2, 1], [4, -1, 2]]
class sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableaux(cartan_type, r, s)

Bases: sage.combinat.crystals.tensor_product.CrystalOfWords

Kirillov-Reshetikhin tableaux.

Kirillov-Reshetikhin tableaux are rectangular tableaux with r rows and s columns that naturally arise under the bijection between rigged configurations and tableaux [RigConBijection]. They are in bijection with the elements of the Kirillov-Reshetikhin crystal B^{r,s} under the (inverse) filling map.

Whenever B^{r,s} \cong B(s\Lambda_r) as a classical crystal (which is the case for B^{r,s} in type A_n^{(1)}, B^{n,s} in type C_n^{(1)} and D_{n+1}^{(2)}, B^{n,s} and B^{n-1,s} in type D_n^{(1)}) then the filling map is trivial.

For B^{r,s} in:

  • type D_n^{(1)} when r \leq n-2,
  • type B_n^{(1)} when r < n,
  • type A_{2n-1}^{(2)} for all r,

the filling map is defined in [OSS2011].

For the spinor cases in type D_n^{(1)}, the crystal B^{k,s} where k = n-1, n, is isomorphic as a classical crystal to B(s\Lambda_k), and here we consider the Kirillov-Reshetikhin tableaux as living in B(2s \Lambda_k) under the natural doubling map. In this case, the crystal operators e_i and f_i act as e_i^2 and f_i^2 respectively. See [BijectionDn].

For the spinor case in type B_n^{(1)}, the crystal B^{n,s}, we consider the images under the natural doubling map into B^{n,2s}. The classical components of this crystal are now given by removing 2 \times 2 boxes. The filling map is the same as below (see the non-spin type C_n^{(1)}).

For B^{r,s} in:

  • type C_n^{(1)} when r < n,
  • type A_{2n}^{(2)\dagger} for all r,

the filling map is given as follows. Suppose we are considering the (classically) highest weight element in the classical component B(\lambda). Then we fill it in with the horizontal dominoes [\bar{\imath}, i] in the i-th row from the top (in English notation) and reordering the columns so that they are increasing. Recall from above that B^{n,s} \cong B(s\Lambda_n) in type C^{(1)}_n.

For B^{r,s} in:

  • type A_{2n}^{(2)} for all r,
  • type D_{n+1}^{(2)} when r < n,

the filling map is the same as given in [OSS2011] except for the rightmost column which is given by the column [1, 2, \ldots, k,
\emptyset, \ldots \emptyset] where k = (r+x-1)/2 in Step 3 of [OSS2011].

For the spinor case in type D_{n+1}^{(2)}, the crystal B^{n,s}, we define the filling map in the same way as in type D_n^{(1)}.

Note

The filling map and classical decompositions in non-spinor cases can be classified by how the special node 0 connects with the corresponding classical diagram.

The classical crystal stucture is given by the usual Kashiwara-Nakashima tableaux rules. That is to embed this into B(\Lambda_1)^{\otimes n s} by using the reading word and then applying the classical crystal operator. The affine crystal stucture is given by converting to the corresponding KR crystal element, performing the affine crystal operator, and pulling back to a KR tableau.

For more information about the bijection between rigged configurations and tensor products of Kirillov-Reshetikhin tableaux, see TensorProductOfKirillovReshetikhinTableaux.

Note

The tableaux for all non-simply-laced types are provably correct if the bijection with rigged configurations holds. Therefore this is currently only proven for B^{r,1} or B^{1,s} and in general for types A_n^{(1)} and D_n^{(1)}.

INPUT:

  • cartan_type – the Cartan type
  • r – the Dynkin diagram index (typically the number of rows)
  • s – the number of columns

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 1, model='KR')
sage: elt = KRT(4, 3); elt
[[3], [4]]

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 2, 1, model='KR')
sage: elt = KRT(-1, 1); elt
[[1], [-1]]

We can create highest weight crystals from a given shape or weight:

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 2, 2, model='KR')
sage: KRT.module_generator(shape=[1,1])
[[1, 1], [2, -1]]
sage: KRT.module_generator(column_shape=[2])
[[1, 1], [2, -1]]
sage: WS = RootSystem(['D',4,1]).weight_space()
sage: KRT.module_generator(weight=WS.sum_of_terms([[0,-2],[2,1]]))
[[1, 1], [2, -1]]
sage: WSC = RootSystem(['D',4]).weight_space()
sage: KRT.module_generator(classical_weight=WSC.fundamental_weight(2))
[[1, 1], [2, -1]]

We can go between KashiwaraNakashimaTableaux() and KirillovReshetikhinTableaux elements:

sage: KRCrys = crystals.KirillovReshetikhin(['D', 4, 1], 2, 2, model='KN')
sage: KRTab = crystals.KirillovReshetikhin(['D', 4, 1], 2, 2, model='KR')
sage: elt = KRCrys(3, 2); elt
[[2], [3]]
sage: k = KRTab(elt); k
[[2, 1], [3, -1]]
sage: KRCrys(k)
[[2], [3]]

We check that the classical weights in the classical decompositions agree in a few different type:

sage: KRCrys = crystals.KirillovReshetikhin(['D', 4, 1], 2, 2, model='KN')
sage: KRTab = crystals.KirillovReshetikhin(['D', 4, 1], 2, 2, model='KR')
sage: all(t.classical_weight() == KRCrys(t).classical_weight() for t in KRTab)
True
sage: KRCrys = crystals.KirillovReshetikhin(['B', 3, 1], 2, 2, model='KN')
sage: KRTab = crystals.KirillovReshetikhin(['B', 3, 1], 2, 2, model='KR')
sage: all(t.classical_weight() == KRCrys(t).classical_weight() for t in KRTab)
True
sage: KRCrys = crystals.KirillovReshetikhin(['C', 3, 1], 2, 2, model='KN')
sage: KRTab = crystals.KirillovReshetikhin(['C', 3, 1], 2, 2, model='KR')
sage: all(t.classical_weight() == KRCrys(t).classical_weight() for t in KRTab)
True
sage: KRCrys = crystals.KirillovReshetikhin(['D', 4, 2], 2, 2, model='KN')
sage: KRTab = crystals.KirillovReshetikhin(['D', 4, 2], 2, 2, model='KR')
sage: all(t.classical_weight() == KRCrys(t).classical_weight() for t in KRTab)
True
sage: KRCrys = crystals.KirillovReshetikhin(['A', 4, 2], 2, 2, model='KN')
sage: KRTab = crystals.KirillovReshetikhin(['A', 4, 2], 2, 2, model='KR')
sage: all(t.classical_weight() == KRCrys(t).classical_weight() for t in KRTab)
True
Element

alias of KirillovReshetikhinTableauxElement

classical_decomposition()

Return the classical crystal decomposition of self.

EXAMPLES:

sage: crystals.KirillovReshetikhin(['D', 4, 1], 2, 2, model='KR').classical_decomposition()
The crystal of tableaux of type ['D', 4] and shape(s) [[], [1, 1], [2, 2]]
from_kirillov_reshetikhin_crystal(krc)

Construct an element of self from the Kirillov-Reshetikhin crystal element krc.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 1, model='KR')
sage: C = crystals.KirillovReshetikhin(['A',4,1], 2, 1, model='KN')
sage: krc = C(4,3); krc
[[3], [4]]
sage: KRT.from_kirillov_reshetikhin_crystal(krc)
[[3], [4]]
kirillov_reshetikhin_crystal()

Return the corresponding KR crystal in the Kashiwara-Nakashima model.

EXAMPLES:

sage: crystals.KirillovReshetikhin(['A', 4, 1], 2, 1, model='KR').kirillov_reshetikhin_crystal()
Kirillov-Reshetikhin crystal of type ['A', 4, 1] with (r,s)=(2,1)
module_generator(i=None, **options)

Return the specified module generator.

INPUT:

  • i – The index of the module generator

We can also get a module generator by using one of the following optional arguments:

  • shape – The associated shape
  • column_shape – The shape given as columns (a column of length k correspond to a classical weight \omega_k)
  • weight – The weight
  • classical_weight – The classical weight

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D', 4, 1], 2, 2, model='KR')
sage: KRT.module_generator(1)
[[1, 1], [2, -1]]
sage: KRT.module_generator(shape=[1,1])
[[1, 1], [2, -1]]
sage: KRT.module_generator(column_shape=[2])
[[1, 1], [2, -1]]
sage: WS = RootSystem(['D',4,1]).weight_space()
sage: KRT.module_generator(weight=WS.sum_of_terms([[0,-2],[2,1]]))
[[1, 1], [2, -1]]
sage: WSC = RootSystem(['D',4]).weight_space()
sage: KRT.module_generator(classical_weight=WSC.fundamental_weight(2))
[[1, 1], [2, -1]]

sage: KRT = crystals.KirillovReshetikhin(['A', 3, 1], 2, 2, model='KR')
sage: KRT.module_generator()
[[1, 1], [2, 2]]
r()

Return the value r for this tableaux class which corresponds to the number of rows.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 1, model='KR')
sage: KRT.r()
2
s()

Return the value s for this tableaux class which corresponds to the number of columns.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 1, model='KR')
sage: KRT.s()
1
tensor(*crystals, **options)

Return the tensor product of self with crystals.

If crystals is a list of (a tensor product of) KR tableaux, this returns a TensorProductOfKirillovReshetikhinTableaux.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A', 3, 1], 2, 2, model='KR')
sage: TP = crystals.TensorProductOfKirillovReshetikhinTableaux(['A', 3, 1], [[1,3],[3,1]])
sage: K.tensor(TP, K)
Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1]
 and factor(s) ((2, 2), (1, 3), (3, 1), (2, 2))

sage: C = crystals.KirillovReshetikhin(['A',3,1], 3, 1, model='KN')
sage: K.tensor(K, C)
Full tensor product of the crystals
 [Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and shape (2, 2),
  Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and shape (2, 2),
  Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(3,1)]
class sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableauxElement(parent, list, **options)

Bases: sage.combinat.crystals.tensor_product.TensorProductOfRegularCrystalsElement

A Kirillov-Reshetikhin tableau.

For more information, see KirillovReshetikhinTableaux and TensorProductOfKirillovReshetikhinTableaux.

classical_weight()

Return the classical weight of self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: elt = KRT(3,2,-1,1); elt
[[2, 1], [3, -1]]
sage: elt.classical_weight()
(0, 1, 1, 0)
e(i)

Perform the action of e_i on self.

Todo

Implement a direct action of e_0 without moving to KR crystals.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: KRT.module_generators[0].e(0)
[[-2, 1], [-1, -1]]
epsilon(i)

Compute \epsilon_i of self.

Todo

Implement a direct action of \epsilon_0 without moving to KR crystals.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: KRT.module_generators[0].epsilon(0)
2
f(i)

Perform the action of f_i on self.

Todo

Implement a direct action of f_0 without moving to KR crystals.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: KRT.module_generators[0].f(0)
[[1, 1], [2, -1]]
left_split()

Return the image of self under the left column splitting map.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 3, model='KR')
sage: mg = KRT.module_generators[1]; mg.pp()
  1 -2  1
  2 -1  2
sage: ls = mg.left_split(); ls.pp()
  1 (X)  -2  1
  2      -1  2
sage: ls.parent()
Tensor product of Kirillov-Reshetikhin tableaux of type ['D', 4, 1] and factor(s) ((2, 1), (2, 2))
lusztig_involution()

Return the result of the classical Lusztig involution on self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 3, model='KR')
sage: mg = KRT.module_generators[1]
sage: mg.lusztig_involution()
[[-2, -2, 1], [-1, -1, 2]]
sage: elt = mg.f_string([2,1,3,2]); elt
[[3, -2, 1], [4, -1, 2]]
sage: elt.lusztig_involution()
[[-4, -2, 1], [-3, -1, 2]]
phi(i)

Compute \phi_i of self.

Todo

Compute \phi_0 without moving to KR crystals.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: KRT.module_generators[0].phi(0)
2
pp()

Pretty print self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 2, model='KR')
sage: elt = KRT(2, 1, 4, 3); elt
[[1, 3], [2, 4]]
sage: elt.pp()
1  3
2  4
right_split()

Return the image of self under the right column splitting map.

Let \ast denote the Lusztig involution, and \mathrm{ls} as the left splitting map. The right splitting map is defined as \mathrm{rs} := \ast \circ \mathrm{ls} \circ \ast.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 3, model='KR')
sage: mg = KRT.module_generators[1]; mg.pp()
  1 -2  1
  2 -1  2
sage: ls = mg.right_split(); ls.pp()
 -2  1 (X)   1
 -1  2       2
sage: ls.parent()
Tensor product of Kirillov-Reshetikhin tableaux of type ['D', 4, 1] and factor(s) ((2, 2), (2, 1))
to_array(rows=True)

Return a 2-dimensional array representation of this Kirillov-Reshetikhin element.

If the output is in rows, then it outputs the top row first (in the English convention) from left to right.

For example: if the reading word is [2, 1, 4, 3], so as a 2 \times 2 tableau:

1 3
2 4

we output [[1, 3], [2, 4]].

If the output is in columns, then it outputs the leftmost column first with the bottom element first. In other words this parses the reading word into its columns.

Continuing with the previous example, the output would be [[2, 1], [4, 3]].

INPUT:

  • rows – (Default: True) Set to True if the resulting array is by row, otherwise it is by column.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 2, model='KR')
sage: elt = KRT(2, 1, 4, 3)
sage: elt.to_array()
[[1, 3], [2, 4]]
sage: elt.to_array(False)
[[2, 1], [4, 3]]
to_classical_highest_weight(index_set=None)

Return the classical highest weight element corresponding to self.

INPUT:

  • index_set – (Default: None) Return the highest weight with respect to the index set. If None is passed in, then this uses the classical index set.

OUTPUT:

A pair [H, f_str] where H is the highest weight element and f_str is a list of a_i of f_{a_i} needed to reach H.

EXAMPLES:

sage: KRTab = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: elt = KRTab(3,2,-1,1); elt
[[2, 1], [3, -1]]
sage: elt.to_classical_highest_weight()
[[[1, 1], [2, -1]], [1, 2]]
to_kirillov_reshetikhin_crystal()

Construct a KashiwaraNakashimaTableaux() element from self.

We construct the Kirillov-Reshetikhin crystal element as follows:

  1. Determine the shape \lambda of the KR crystal from the weight.
  2. Determine a path e_{i_1} e_{i_2} \cdots e_{i_k} to the highest weight.
  3. Apply f_{i_k} \cdots f_{i_2} f_{i_1} to a highest weight KR crystal of shape \lambda.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: elt = KRT(3,2,-1,1); elt
[[2, 1], [3, -1]]
sage: elt.to_kirillov_reshetikhin_crystal()
[[2], [3]]

TESTS:

Spinor tests:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 4, 3, model='KR')
sage: KRC = crystals.KirillovReshetikhin(['D',4,1], 4, 3, model='KN')
sage: elt = KRT(-3,-4,2,1,-3,-4,2,1,-2,-4,3,1); elt
[[1, 1, 1], [2, 2, 3], [-4, -4, -4], [-3, -3, -2]]
sage: ret = elt.to_kirillov_reshetikhin_crystal(); ret
[++--, [[1], [3], [-4], [-3]]]
sage: test = KRT(ret); test
[[1, 1, 1], [2, 2, 3], [-4, -4, -4], [-3, -3, -2]]
sage: test == elt
True
to_tableau()

Return a Tableau object of self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['A', 4, 1], 2, 2, model='KR')
sage: elt = KRT(2, 1, 4, 3); elt
[[1, 3], [2, 4]]
sage: t = elt.to_tableau(); t
[[1, 3], [2, 4]]
sage: type(t)
<class 'sage.combinat.tableau.Tableaux_all_with_category.element_class'>
weight()

Return the weight of self.

EXAMPLES:

sage: KR = crystals.KirillovReshetikhin(['D',4,1], 2, 2, model='KR')
sage: KR.module_generators[1].weight()
-2*Lambda[0] + Lambda[2]

Previous topic

Kleber Trees

Next topic

Crystal of Rigged Configurations

This Page