Kirillov-Reshetikhin tableaux are rectangular tableaux with rows and
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
under the (inverse)
filling map. 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:
Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxTypeHorizonal
Kirillov-Reshetkhin tableaux of type
.
TESTS:
sage: KRT = crystals.KirillovReshetikhin(['B', 2, 1], 2, 3, model='KR')
sage: TestSuite(KRT).run()
alias of KRTableauxSpinElement
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]]
Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxRectangle
Kirillov-Reshetikhin tableaux of type
with
.
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
alias of KRTableauxSpinElement
Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableaux
Kirillov-Reshetkhin tableaux whose module generator is a single
rectangle.
These are Kirillov-Reshetkhin tableaux of type:
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
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]]
Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxRectangle
Kirillov-Reshetikhin tableaux of type
with
.
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()
alias of KRTableauxSpinElement
Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableauxElement
Kirillov-Reshetikhin tableau for spinors.
Here we are in the embedding , so
and
act by
and
respectively for all
. We do this so our columns are full
width (as opposed to half width and/or uses a
representation).
Calculate the action of 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)
Compute 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
Calculate the action of 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]]
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
Compute 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
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 , so as a
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:
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]]
Bases: sage.combinat.rigged_configurations.kr_tableaux.KRTableauxTypeVertical
Kirillov-Reshetikhin tableaux of type:
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
Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableaux
Kirillov-Reshetikhin tableaux of type:
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()
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]]
Bases: sage.combinat.rigged_configurations.kr_tableaux.KirillovReshetikhinTableaux
Kirillov-Reshetkihn tableaux of type:
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
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]]
Bases: sage.combinat.crystals.tensor_product.CrystalOfWords
Kirillov-Reshetikhin tableaux.
Kirillov-Reshetikhin tableaux are rectangular tableaux with rows and
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
under the
(inverse) filling map.
Whenever as a classical crystal (which is
the case for
in type
,
in type
and
,
and
in type
) then the filling map is trivial.
For in:
the filling map is defined in [OSS2011].
For the spinor cases in type , the crystal
where
, is isomorphic as a classical crystal to
,
and here we consider the Kirillov-Reshetikhin tableaux as living in
under the natural doubling map. In this case, the
crystal operators
and
act as
and
respectively.
See [BijectionDn].
For the spinor case in type , the crystal
, we
consider the images under the natural doubling map into
.
The classical components of this crystal are now given by
removing
boxes. The filling map is the same as below
(see the non-spin type
).
For in:
the filling map is given as follows. Suppose we are considering the
(classically) highest weight element in the classical component
. Then we fill it in with the horizontal dominoes
in the
-th row from the top (in English notation)
and reordering the columns so that they are increasing. Recall from above
that
in type
.
For in:
the filling map is the same as given in [OSS2011] except for
the rightmost column which is given by the column where
in Step 3 of
[OSS2011].
For the spinor case in type , the crystal
, we
define the filling map in the same way as in type
.
Note
The filling map and classical decompositions in non-spinor cases can
be classified by how the special node 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
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 or
and in general for types
and
.
INPUT:
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
alias of KirillovReshetikhinTableauxElement
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]]
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]]
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)
Return the specified module generator.
INPUT:
We can also get a module generator by using one of the following optional arguments:
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]]
Return the value 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
Return the value 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
Bases: sage.combinat.crystals.tensor_product.TensorProductOfRegularCrystalsElement
A Kirillov-Reshetikhin tableau.
For more information, see KirillovReshetikhinTableaux and TensorProductOfKirillovReshetikhinTableaux.
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)
Perform the action of on self.
Todo
Implement a direct action of 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]]
Compute of self.
Todo
Implement a direct action of 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
Perform the action of on self.
Todo
Implement a direct action of 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]]
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))
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]]
Compute of self.
Todo
Compute 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
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
Return the image of self under the right column splitting map.
Let denote the Lusztig involution,
and
as the left splitting map.
The right splitting map is defined as
.
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))
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 , so as a
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:
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]]
Return the classical highest weight element corresponding to self.
INPUT:
OUTPUT:
A pair [H, f_str] where H is the highest weight element and
f_str is a list of of
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]]
Construct a KashiwaraNakashimaTableaux() element from self.
We construct the Kirillov-Reshetikhin crystal element as follows:
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
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'>
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]