Tensor Product of Kirillov-Reshetikhin Tableaux#

A tensor product of KirillovReshetikhinTableaux which are tableaux of \(r\) rows and \(s\) columns which naturally arise in the bijection between rigged configurations and tableaux and which are in bijection with the elements of the Kirillov-Reshetikhin crystal \(B^{r,s}\), see KirillovReshetikhinCrystal().

AUTHORS:

  • Travis Scrimshaw (2010-09-26): Initial version

EXAMPLES:

Type \(A_n^{(1)}\) examples:

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[3,1], [2,1]])
sage: KRT
Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and factor(s) ((3, 1), (2, 1))
sage: KRT.cardinality()
24
sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[1,1], [2,1], [3,1]])
sage: KRT
Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and factor(s) ((1, 1), (2, 1), (3, 1))
sage: len(KRT.module_generators)
5
sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[1,1], [2,1], [3,1]])
sage: KRT.cardinality()
96

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(3),Integer(1)], [Integer(2),Integer(1)]])
>>> KRT
Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and factor(s) ((3, 1), (2, 1))
>>> KRT.cardinality()
24
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(1),Integer(1)], [Integer(2),Integer(1)], [Integer(3),Integer(1)]])
>>> KRT
Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and factor(s) ((1, 1), (2, 1), (3, 1))
>>> len(KRT.module_generators)
5
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(1),Integer(1)], [Integer(2),Integer(1)], [Integer(3),Integer(1)]])
>>> KRT.cardinality()
96

Type \(D_n^{(1)}\) examples:

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 1], [[1, 1], [2, 1], [1, 1]])
sage: KRT
Tensor product of Kirillov-Reshetikhin tableaux of type ['D', 4, 1] and factor(s) ((1, 1), (2, 1), (1, 1))
sage: T = KRT(pathlist=[[1], [-2, 2], [1]])
sage: T
[[1]] (X) [[2], [-2]] (X) [[1]]
sage: T2 = KRT(pathlist=[[1], [2, -2], [1]])
sage: T2
[[1]] (X) [[-2], [2]] (X) [[1]]
sage: T == T2
False

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', Integer(4), Integer(1)], [[Integer(1), Integer(1)], [Integer(2), Integer(1)], [Integer(1), Integer(1)]])
>>> KRT
Tensor product of Kirillov-Reshetikhin tableaux of type ['D', 4, 1] and factor(s) ((1, 1), (2, 1), (1, 1))
>>> T = KRT(pathlist=[[Integer(1)], [-Integer(2), Integer(2)], [Integer(1)]])
>>> T
[[1]] (X) [[2], [-2]] (X) [[1]]
>>> T2 = KRT(pathlist=[[Integer(1)], [Integer(2), -Integer(2)], [Integer(1)]])
>>> T2
[[1]] (X) [[-2], [2]] (X) [[1]]
>>> T == T2
False
class sage.combinat.rigged_configurations.tensor_product_kr_tableaux.HighestWeightTensorKRT(tp_krt)[source]#

Bases: UniqueRepresentation

Class so we do not have to build the module generators for TensorProductOfKirillovReshetikhinTableaux at initialization.

Warning

This class is for internal use only!

cardinality()[source]#

Return the cardinality of self, which is the number of highest weight elements.

EXAMPLES:

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D',4,1], [[2,2]])
sage: from sage.combinat.rigged_configurations.tensor_product_kr_tableaux import HighestWeightTensorKRT
sage: HW = HighestWeightTensorKRT(KRT)
sage: HW.cardinality()
3
sage: len(HW)
3
sage: len(KRT.module_generators)
3

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D',Integer(4),Integer(1)], [[Integer(2),Integer(2)]])
>>> from sage.combinat.rigged_configurations.tensor_product_kr_tableaux import HighestWeightTensorKRT
>>> HW = HighestWeightTensorKRT(KRT)
>>> HW.cardinality()
3
>>> len(HW)
3
>>> len(KRT.module_generators)
3
class sage.combinat.rigged_configurations.tensor_product_kr_tableaux.TensorProductOfKirillovReshetikhinTableaux(cartan_type, B)[source]#

Bases: FullTensorProductOfRegularCrystals

A tensor product of KirillovReshetikhinTableaux.

Through the bijection with rigged configurations, the tableaux that are produced in all nonexceptional types are all of rectangular shapes and do not necessarily obey the usual strict increase in columns and weak increase in rows. The relation between the elements of the Kirillov-Reshetikhin crystal, given by the Kashiwara-Nakashima tableaux, and the Kirillov-Reshetikhin tableaux is given by a filling map.

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)}\).

For more information see [OSS2011] and KirillovReshetikhinTableaux.

For more information on KR crystals, see sage.combinat.crystals.kirillov_reshetikhin.

INPUT:

  • cartan_type – a Cartan type

  • B – an (ordered) list of pairs \((r,s)\) which give the dimension of a rectangle with \(r\) rows and \(s\) columns and corresponds to a Kirillov-Reshetikhin tableaux factor of \(B^{r,s}\).

REFERENCES:

[OSS2011]

Masato Okado, Reiho Sakamoto, Anne Schilling, Affine crystal structure on rigged configurations of type \(D_n^{(1)}\), J. Algebraic Combinatorics 37(3) (2013) 571-599 (arXiv 1109.3523 [math.QA])

EXAMPLES:

We can go between tensor products of KR crystals and rigged configurations:

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[3,1],[2,2]])
sage: tp_krt = KRT(pathlist=[[3,2,1],[3,2,3,2]]); tp_krt
[[1], [2], [3]] (X) [[2, 2], [3, 3]]
sage: RC = RiggedConfigurations(['A',3,1], [[3,1],[2,2]])
sage: rc_elt = tp_krt.to_rigged_configuration(); rc_elt

-2[ ][ ]-2

0[ ][ ]0

(/)

sage: tp_krc = tp_krt.to_tensor_product_of_kirillov_reshetikhin_crystals(); tp_krc
[[[1], [2], [3]], [[2, 2], [3, 3]]]
sage: KRT(tp_krc) == tp_krt
True
sage: rc_elt == tp_krt.to_rigged_configuration()
True
sage: KR1 = crystals.KirillovReshetikhin(['A',3,1], 3,1)
sage: KR2 = crystals.KirillovReshetikhin(['A',3,1], 2,2)
sage: T = crystals.TensorProduct(KR1, KR2)
sage: t = T(KR1(3,2,1), KR2(3,2,3,2))
sage: KRT(t) == tp_krt
True
sage: t == tp_krc
True

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(3),Integer(1)],[Integer(2),Integer(2)]])
>>> tp_krt = KRT(pathlist=[[Integer(3),Integer(2),Integer(1)],[Integer(3),Integer(2),Integer(3),Integer(2)]]); tp_krt
[[1], [2], [3]] (X) [[2, 2], [3, 3]]
>>> RC = RiggedConfigurations(['A',Integer(3),Integer(1)], [[Integer(3),Integer(1)],[Integer(2),Integer(2)]])
>>> rc_elt = tp_krt.to_rigged_configuration(); rc_elt
<BLANKLINE>
-2[ ][ ]-2
<BLANKLINE>
0[ ][ ]0
<BLANKLINE>
(/)
<BLANKLINE>
>>> tp_krc = tp_krt.to_tensor_product_of_kirillov_reshetikhin_crystals(); tp_krc
[[[1], [2], [3]], [[2, 2], [3, 3]]]
>>> KRT(tp_krc) == tp_krt
True
>>> rc_elt == tp_krt.to_rigged_configuration()
True
>>> KR1 = crystals.KirillovReshetikhin(['A',Integer(3),Integer(1)], Integer(3),Integer(1))
>>> KR2 = crystals.KirillovReshetikhin(['A',Integer(3),Integer(1)], Integer(2),Integer(2))
>>> T = crystals.TensorProduct(KR1, KR2)
>>> t = T(KR1(Integer(3),Integer(2),Integer(1)), KR2(Integer(3),Integer(2),Integer(3),Integer(2)))
>>> KRT(t) == tp_krt
True
>>> t == tp_krc
True

We can get the highest weight elements by using the attribute module_generators:

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[3,1], [2,1]])
sage: list(KRT.module_generators)
[[[1], [2], [3]] (X) [[1], [2]], [[1], [3], [4]] (X) [[1], [2]]]

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(3),Integer(1)], [Integer(2),Integer(1)]])
>>> list(KRT.module_generators)
[[[1], [2], [3]] (X) [[1], [2]], [[1], [3], [4]] (X) [[1], [2]]]

To create elements directly (i.e. not passing in KR tableaux elements), there is the pathlist option will receive a list of lists which contain the reversed far-eastern reading word of the tableau. That is to say, in English notation, the word obtain from reading bottom-to-top, left-to-right.

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[3,2], [1,2], [2,1]])
sage: elt = KRT(pathlist=[[3, 2, 1, 4, 2, 1], [1, 3], [3, 1]])
sage: elt.pp()
  1  1 (X)   1  3 (X)   1
  2  2                  3
  3  4

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(3),Integer(2)], [Integer(1),Integer(2)], [Integer(2),Integer(1)]])
>>> elt = KRT(pathlist=[[Integer(3), Integer(2), Integer(1), Integer(4), Integer(2), Integer(1)], [Integer(1), Integer(3)], [Integer(3), Integer(1)]])
>>> elt.pp()
  1  1 (X)   1  3 (X)   1
  2  2                  3
  3  4

One can still create elements in the same way as tensor product of crystals:

sage: K1 = crystals.KirillovReshetikhin(['A',3,1], 3, 2, model='KR')
sage: K2 = crystals.KirillovReshetikhin(['A',3,1], 1, 2, model='KR')
sage: K3 = crystals.KirillovReshetikhin(['A',3,1], 2, 1, model='KR')
sage: eltlong = KRT(K1(3, 2, 1, 4, 2, 1), K2(1, 3), K3(3, 1))
sage: eltlong == elt
True

>>> from sage.all import *
>>> K1 = crystals.KirillovReshetikhin(['A',Integer(3),Integer(1)], Integer(3), Integer(2), model='KR')
>>> K2 = crystals.KirillovReshetikhin(['A',Integer(3),Integer(1)], Integer(1), Integer(2), model='KR')
>>> K3 = crystals.KirillovReshetikhin(['A',Integer(3),Integer(1)], Integer(2), Integer(1), model='KR')
>>> eltlong = KRT(K1(Integer(3), Integer(2), Integer(1), Integer(4), Integer(2), Integer(1)), K2(Integer(1), Integer(3)), K3(Integer(3), Integer(1)))
>>> eltlong == elt
True
Element[source]#

alias of TensorProductOfKirillovReshetikhinTableauxElement

rigged_configurations()[source]#

Return the corresponding set of rigged configurations.

EXAMPLES:

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[1,3], [2,1]])
sage: KRT.rigged_configurations()
Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 3), (2, 1))

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(1),Integer(3)], [Integer(2),Integer(1)]])
>>> KRT.rigged_configurations()
Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 3), (2, 1))
tensor(*crystals, **options)[source]#

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

sage: C = crystals.KirillovReshetikhin(['A',3,1], 3, 1, model='KN')
sage: TP.tensor(K, C)
Full tensor product of the crystals
 [Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and shape (1, 3),
  Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and shape (3, 1),
  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)]

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

>>> C = crystals.KirillovReshetikhin(['A',Integer(3),Integer(1)], Integer(3), Integer(1), model='KN')
>>> TP.tensor(K, C)
Full tensor product of the crystals
 [Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and shape (1, 3),
  Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and shape (3, 1),
  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)]
tensor_product_of_kirillov_reshetikhin_crystals()[source]#

Return the corresponding tensor product of Kirillov-Reshetikhin crystals.

EXAMPLES:

sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[3,1],[2,2]])
sage: KRT.tensor_product_of_kirillov_reshetikhin_crystals()
Full tensor product of the crystals [Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(3,1),
Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(2,2)]

>>> from sage.all import *
>>> KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',Integer(3),Integer(1)], [[Integer(3),Integer(1)],[Integer(2),Integer(2)]])
>>> KRT.tensor_product_of_kirillov_reshetikhin_crystals()
Full tensor product of the crystals [Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(3,1),
Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(2,2)]