AUTHORS:
Deprecated in trac ticket #13872. Use instead the attribute module_generators of RiggedConfigurations.
EXAMPLES:
sage: HighestWeightRiggedConfigurations(['A',2,1], [[1,1]])
doctest:...: DeprecationWarning: this class is deprecated.
Use RiggedConfigurations(cartan_type, B).module_generators instead
See http://trac.sagemath.org/13872 for details.
(
(/)
(/)
)
Return the KR crystal using
rigged configurations.
This is the rigged configuration or
with
and
.
EXAMPLES:
sage: K1 = crystals.kirillov_reshetikhin.RiggedConfigurations(['A',6,2], 2, 1)
sage: K2 = crystals.kirillov_reshetikhin.LSPaths(['A',6,2], 2, 1)
sage: K1.digraph().is_isomorphic(K2.digraph(), edge_labels=True)
True
Bases: sage.combinat.rigged_configurations.rigged_configurations.RiggedConfigurations
Rigged configurations in non-simply-laced types.
These are rigged configurations which lift to virtual rigged configurations in a simply-laced type.
For more on rigged configurations, see RiggedConfigurations.
alias of RCNonSimplyLacedElement
Convert vrc in the virtual crystal into a rigged configution of the original Cartan type.
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['C',2,1], [[1,2],[1,1],[2,1]])
sage: elt = RC(partition_list=[[3],[2]])
sage: vrc_elt = RC.to_virtual(elt)
sage: ret = RC.from_virtual(vrc_elt); ret
0[ ][ ][ ]0
0[ ][ ]0
sage: ret == elt
True
Return the underlying (virtual) Kleber tree used to generate all highest weight rigged configurations.
EXAMPLES:
sage: RC = RiggedConfigurations(['C',3,1], [[1,1], [2,1]])
sage: RC.kleber_tree()
Virtual Kleber tree of Cartan type ['C', 3, 1] and B = ((1, 1), (2, 1))
Module generators for this set of rigged configurations.
Iterate over the highest weight rigged configurations by moving through the KleberTree and then setting appropriate values of the partitions.
EXAMPLES:
sage: RC = RiggedConfigurations(['C', 3, 1], [[1,2]])
sage: for x in RC.module_generators: x
(/)
(/)
(/)
0[ ][ ]0
0[ ][ ]0
0[ ]0
Convert rc into a rigged configuration in the virtual crystal.
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['C',2,1], [[1,2],[1,1],[2,1]])
sage: elt = RC(partition_list=[[3],[2]]); elt
0[ ][ ][ ]0
0[ ][ ]0
sage: velt = RC.to_virtual(elt); velt
0[ ][ ][ ]0
0[ ][ ][ ][ ]0
0[ ][ ][ ]0
sage: velt.parent()
Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 2))
Return the corresponding virtual crystal.
EXAMPLES:
sage: RC = RiggedConfigurations(['C',2,1], [[1,2],[1,1],[2,1]])
sage: RC
Rigged configurations of type ['C', 2, 1] and factor(s) ((1, 2), (1, 1), (2, 1))
sage: RC.virtual
Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 2))
Bases: sage.combinat.rigged_configurations.rigged_configurations.RCTypeA2Even
Rigged configurations of type .
For more on rigged configurations, see RiggedConfigurations.
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[1,2],[1,1],[2,1]])
sage: RC
Rigged configurations of type ['BC', 2, 2]^* and factor(s) ((1, 2), (1, 1), (2, 1))
sage: RC.cardinality()
750
sage: RC.virtual
Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 1), (2, 1))
sage: RC = RiggedConfigurations(CartanType(['A',2,2]).dual(), [[1,1]])
sage: RC.cardinality()
3
sage: RC = RiggedConfigurations(CartanType(['A',2,2]).dual(), [[1,2],[1,1]])
sage: TestSuite(RC).run() # long time
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[2,1]])
sage: TestSuite(RC).run() # long time
Convert vrc in the virtual crystal into a rigged configution of the original Cartan type.
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[2,2]])
sage: elt = RC(partition_list=[[1],[1]])
sage: velt = RC.to_virtual(elt)
sage: ret = RC.from_virtual(velt); ret
-1[ ]-1
1[ ]1
sage: ret == elt
True
Module generators for rigged configurations of type
.
Iterate over the highest weight rigged configurations by moving
through the
KleberTree
and then setting appropriate values of the partitions. This also
skips rigged configurations where when
is odd.
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A', 4, 2]).dual(), [[1,1]])
sage: for x in RC.module_generators: x
(/)
(/)
Convert rc into a rigged configuration in the virtual crystal.
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[2,2]])
sage: elt = RC(partition_list=[[1],[1]]); elt
-1[ ]-1
1[ ]1
sage: velt = RC.to_virtual(elt); velt
-1[ ]-1
2[ ]2
-1[ ]-1
sage: velt.parent()
Rigged configurations of type ['A', 3, 1] and factor(s) ((2, 2), (2, 2))
Bases: sage.combinat.rigged_configurations.rigged_configurations.RCNonSimplyLaced
Rigged configurations for type .
For more on rigged configurations, see RiggedConfigurations.
EXAMPLES:
sage: RC = RiggedConfigurations(['A',4,2], [[2,1], [1,2]])
sage: RC.cardinality()
150
sage: RC = RiggedConfigurations(['A',2,2], [[1,1]])
sage: RC.cardinality()
3
sage: RC = RiggedConfigurations(['A',2,2], [[1,2],[1,1]])
sage: TestSuite(RC).run() # long time
sage: RC = RiggedConfigurations(['A',4,2], [[2,1]])
sage: TestSuite(RC).run() # long time
Return the cardinality of self.
EXAMPLES:
sage: RC = RiggedConfigurations(['A',4,2], [[1,1], [2,2]])
sage: RC.cardinality()
250
Convert vrc in the virtual crystal into a rigged configution of the original Cartan type.
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['A',4,2], [[2,2]])
sage: elt = RC(partition_list=[[1],[1]])
sage: velt = RC.to_virtual(elt)
sage: ret = RC.from_virtual(velt); ret
-1[ ]-1
1[ ]1
sage: ret == elt
True
Convert rc into a rigged configuration in the virtual crystal.
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['A',4,2], [[2,2]])
sage: elt = RC(partition_list=[[1],[1]]); elt
-1[ ]-1
1[ ]1
sage: velt = RC.to_virtual(elt); velt
-1[ ]-1
2[ ]2
-1[ ]-1
sage: velt.parent()
Rigged configurations of type ['A', 3, 1] and factor(s) ((2, 2), (2, 2))
Return the corresponding virtual crystal.
EXAMPLES:
sage: RC = RiggedConfigurations(['A',4,2], [[1,2],[1,1],[2,1]])
sage: RC
Rigged configurations of type ['BC', 2, 2] and factor(s) ((1, 2), (1, 1), (2, 1))
sage: RC.virtual
Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 1), (2, 1))
Bases: sage.structure.parent.Parent, sage.structure.unique_representation.UniqueRepresentation
Rigged configurations as -crystals.
Let denote the classical index set associated to the Cartan
type of the rigged configurations. A rigged configuration of multiplicity
array
and dominant weight
is a sequence of partitions
such that
where is a simple root,
is a fundamental weight,
and
is the number of rows of length
in the partition
.
Each partition , in the sequence also comes with a sequence of
statistics
called vacancy numbers and a weakly decreasing
sequence
of length
called riggings.
Vacancy numbers are computed based upon the partitions and
,
and the riggings must satisfy
. We call
such a partition a rigged partition. For more, see
[RigConBijection] [CrysStructSchilling06] [BijectionLRT].
Rigged configurations form combinatorial objects first introduced by Kerov, Kirillov and Reshetikhin that arose from studies of statistical mechanical models using the Bethe Ansatz. They are sequences of rigged partitions. A rigged partition is a partition together with a label associated to each part that satisfy certain constraints. The labels are also called riggings.
Rigged configurations exist for all affine Kac-Moody Lie algebras. See
for example [HKOTT2002]. In Sage they are specified by providing a Cartan
type and a list of rectangular shapes . The list of all (highest
weight) rigged configurations for given
is computed via the (virtual)
Kleber algorithm (see also
KleberTree and
VirtualKleberTree).
Rigged configurations in simply-laced types all admit a classical crystal structure [CrysStructSchilling06]. For non-simply-laced types, the crystal is given by using virtual rigged configurations [OSS03]. The highest weight rigged configurations are those where all riggings are nonnegative. The list of all rigged configurations is computed from the highest weight ones using the crystal operators.
Rigged configurations are conjecturally in bijection with
TensorProductOfKirillovReshetikhinTableaux
of non-exceptional affine types where the list corresponds to the
tensor factors
. The bijection has been proven in types
and
and when the only non-zero entries of
are either
only
or only
(corresponding to single columns or
rows respectively) [RigConBijection], [BijectionLRT], [BijectionDn].
KR crystals are implemented in Sage, see KirillovReshetikhinCrystal(), however, in the bijection with rigged configurations a different realization of the elements in the crystal are obtained, which are coined KR tableaux, see KirillovReshetikhinTableaux. For more details see [OSS2011].
Note
All non-simply-laced rigged configurations have not been proven to give rise to aligned virtual crystals (i.e. have the correct crystal structure or ismorphic as affine crystals to the tensor product of KR tableaux).
INPUT:
REFERENCES:
[HKOTT2002] | (1, 2) G. Hatayama, A. Kuniba, M. Okado, T. Takagi, Z. Tsuboi. Paths, Crystals and Fermionic Formulae. Prog. Math. Phys. 23 (2002) Pages 205-272. |
[CrysStructSchilling06] | (1, 2) Anne Schilling. Crystal structure on rigged configurations. International Mathematics Research Notices. Volume 2006. (2006) Article ID 97376. Pages 1-27. |
[RigConBijection] | (1, 2) Masato Okado, Anne Schilling, Mark Shimozono. A crystal to rigged configuration bijection for non-exceptional affine algebras. Algebraic Combinatorics and Quantum Groups. Edited by N. Jing. World Scientific. (2003) Pages 85-124. |
[BijectionDn] | (1, 2) Anne Schilling.
A bijection between type ![]() |
[BijectionLRT] | (1, 2, 3) Anatol N. Kirillov, Anne Schilling, Mark Shimozono. A bijection between Littlewood-Richardson tableaux and rigged configurations. Selecta Mathematica (N.S.). 8 (2002) Pages 67-135. (MathSciNet MR1890195). |
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2], [1, 1]])
sage: RC
Rigged configurations of type ['A', 3, 1] and factor(s) ((3, 2), (1, 2), (1, 1))
sage: RC = RiggedConfigurations(['A', 3, 1], [[2,1]]); RC
Rigged configurations of type ['A', 3, 1] and factor(s) ((2, 1),)
sage: RC.cardinality()
6
sage: len(RC.list()) == RC.cardinality()
True
sage: RC.list()
[
0[ ]0
(/) (/) (/) -1[ ]-1 -1[ ]-1
-1[ ]-1
(/) -1[ ]-1 0[ ]0 0[ ]0 1[ ]1 -1[ ]-1
(/) (/) -1[ ]-1 (/) -1[ ]-1 0[ ]0
, , , , ,
]
A rigged configuration element with all riggings equal to the vacancy numbers can be created as follows:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3,2], [2,1], [1,1], [1,1]]); RC
Rigged configurations of type ['A', 3, 1] and factor(s) ((3, 2), (2, 1), (1, 1), (1, 1))
sage: elt = RC(partition_list=[[1],[],[]]); elt
0[ ]0
(/)
(/)
If on the other hand we also want to specify the riggings, this can be achieved as follows:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2], [1, 1]])
sage: RC(partition_list=[[2],[2],[2]])
1[ ][ ]1
0[ ][ ]0
0[ ][ ]0
sage: RC(partition_list=[[2],[2],[2]], rigging_list=[[0],[0],[0]])
1[ ][ ]0
0[ ][ ]0
0[ ][ ]0
A larger example:
sage: RC = RiggedConfigurations(['D', 7, 1], [[3,3],[5,2],[4,3],[2,3],[4,4],[3,1],[1,4],[2,2]])
sage: elt = RC(partition_list=[[2],[3,2,1],[2,2,1,1],[2,2,1,1,1,1],[3,2,1,1,1,1],[2,1,1],[2,2]],
....: rigging_list=[[2],[1,0,0],[4,1,2,1],[1,0,0,0,0,0],[0,1,0,0,0,0],[0,0,0],[0,0]])
sage: elt
3[ ][ ]2
1[ ][ ][ ]1
2[ ][ ]0
1[ ]0
4[ ][ ]4
4[ ][ ]1
3[ ]2
3[ ]1
2[ ][ ]1
2[ ][ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ][ ][ ]0
2[ ][ ]1
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ][ ]0
0[ ]0
0[ ]0
0[ ][ ]0
0[ ][ ]0
To obtain the KR tableau under the bijection between rigged configurations and KR tableaux, we can type the following. This example was checked against Reiho Sakamoto’s Mathematica program on rigged configurations:
sage: output = elt.to_tensor_product_of_kirillov_reshetikhin_tableaux(); output
[[1, 1, 1], [2, 3, 3], [3, 4, -5]] (X) [[1, 1], [2, 2], [3, 3], [5, -6], [6, -5]] (X)
[[1, 1, 2], [2, 2, 3], [3, 3, 7], [4, 4, -7]] (X) [[1, 1, 1], [2, 2, 2]] (X)
[[1, 1, 1, 3], [2, 2, 3, 4], [3, 3, 4, 5], [4, 4, 5, 6]] (X) [[1], [2], [3]] (X) [[1, 1, 1, 1]] (X) [[1, 1], [2, 2]]
sage: elt.to_tensor_product_of_kirillov_reshetikhin_tableaux().to_rigged_configuration() == elt
True
sage: output.to_rigged_configuration().to_tensor_product_of_kirillov_reshetikhin_tableaux() == output
True
We can also convert between rigged configurations and tensor products of KR crystals:
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 1]])
sage: elt = RC(partition_list=[[1],[1,1],[1],[1]])
sage: tp_krc = elt.to_tensor_product_of_kirillov_reshetikhin_crystals(); tp_krc
[[]]
sage: ret = RC(tp_krc)
sage: ret == elt
True
sage: RC = RiggedConfigurations(['D', 4, 1], [[4,1], [3,3]])
sage: KR1 = crystals.KirillovReshetikhin(['D', 4, 1], 4, 1)
sage: KR2 = crystals.KirillovReshetikhin(['D', 4, 1], 3, 3)
sage: T = crystals.TensorProduct(KR1, KR2)
sage: t = T[1]; t
[[++++, []], [+++-, [[1], [2], [4], [-4]]]]
sage: ret = RC(t)
sage: ret.to_tensor_product_of_kirillov_reshetikhin_crystals()
[[++++, []], [+++-, [[1], [2], [4], [-4]]]]
TESTS:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3,2], [2,1], [1,1], [1,1]])
sage: len(RC.module_generators)
17
sage: RC = RiggedConfigurations(['D', 4, 1], [[1, 1]])
sage: RC.cardinality()
8
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 1]])
sage: c = RC.cardinality(); c
29
sage: K = crystals.KirillovReshetikhin(['D',4,1],2,1)
sage: K.cardinality() == c
True
alias of RiggedConfigurationElement
Return the cardinality of self.
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2]])
sage: RC.cardinality()
100
sage: RC = RiggedConfigurations(['B', 3, 1], [[2,2],[1,2]])
sage: RC.cardinality()
5130
sage: RC = RiggedConfigurations(['E', 7, 1], [[1,1]])
sage: RC.cardinality()
134
Return the fermoinic formula associated to self.
Given a set of rigged configurations , the fermonic
formula is defined as:
where we sum over all (classically highest weight) rigged
configurations of weight where
is the
cocharge statistic.
This is known to reduce to
The generating function of in the weight algebra
subsumes all fermionic formulas:
This is conjecturally equal to the
one dimensional configuration sum
of the corresponding tensor product of Kirillov-Reshetikhin crystals, see [HKOTT2002].
This has been proven in general for type [BijectionLRT],
single factors
in type
[OSS2011] with the result
from [Sakamoto13], as well as for a tensor product of single columns
[OSS2003], [BijectionDn] or a tensor product of single rows [OSS03]
for all non-exceptional types.
INPUT:
REFERENCES:
[OSS2003] | Masato Okado, Anne Schilling, and Mark Shimozono.
Virtual crystals and fermionic formulas of type ![]() ![]() ![]() |
[Sakamoto13] | Reiho Sakamoto. Rigged configurations and Kashiwara operators. (2013) Arxiv 1302.4562v1. |
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 2, 1], [[1,1], [1,1]])
sage: RC.fermionic_formula()
B[-2*Lambda[1] + 2*Lambda[2]] + (q+1)*B[-Lambda[1]]
+ (q+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
+ B[-2*Lambda[2]] + (q+1)*B[Lambda[2]]
sage: t = QQ['t'].gen(0)
sage: RC.fermionic_formula(t)
B[-2*Lambda[1] + 2*Lambda[2]] + (t+1)*B[-Lambda[1]]
+ (t+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
+ B[-2*Lambda[2]] + (t+1)*B[Lambda[2]]
sage: La = RC.weight_lattice_realization().classical().fundamental_weights()
sage: RC.fermionic_formula(weight=La[2])
q + 1
sage: RC.fermionic_formula(only_highest_weight=True, weight=La[2])
q
Only using the highest weight elements on other types:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3,1], [2,2]])
sage: RC.fermionic_formula(only_highest_weight=True)
q*B[Lambda[1] + Lambda[2]] + B[2*Lambda[2] + Lambda[3]]
sage: RC = RiggedConfigurations(['D', 4, 1], [[3,1], [4,1], [2,1]])
sage: RC.fermionic_formula(only_highest_weight=True)
(q^4+q^3+q^2)*B[Lambda[1]] + (q^2+q)*B[Lambda[1] + Lambda[2]]
+ q*B[Lambda[1] + 2*Lambda[3]] + q*B[Lambda[1] + 2*Lambda[4]]
+ B[Lambda[2] + Lambda[3] + Lambda[4]] + (q^3+2*q^2+q)*B[Lambda[3] + Lambda[4]]
sage: RC = RiggedConfigurations(['E', 6, 1], [[2,2]])
sage: RC.fermionic_formula(only_highest_weight=True)
q^2*B[0] + q*B[Lambda[2]] + B[2*Lambda[2]]
sage: RC = RiggedConfigurations(['B', 3, 1], [[3,1], [2,2]])
sage: RC.fermionic_formula(only_highest_weight=True) # long time
q*B[Lambda[1] + Lambda[2] + Lambda[3]] + q^2*B[Lambda[1]
+ Lambda[3]] + (q^2+q)*B[Lambda[2] + Lambda[3]] + B[2*Lambda[2]
+ Lambda[3]] + (q^3+q^2)*B[Lambda[3]]
sage: RC = RiggedConfigurations(['C', 3, 1], [[3,1], [2,2]])
sage: RC.fermionic_formula(only_highest_weight=True) # long time
(q^3+q^2)*B[Lambda[1] + Lambda[2]] + q*B[Lambda[1] + 2*Lambda[2]]
+ (q^2+q)*B[2*Lambda[1] + Lambda[3]] + B[2*Lambda[2] + Lambda[3]]
+ (q^4+q^3+q^2)*B[Lambda[3]]
sage: RC = RiggedConfigurations(['D', 4, 2], [[3,1], [2,2]])
sage: RC.fermionic_formula(only_highest_weight=True) # long time
(q^2+q)*B[Lambda[1] + Lambda[2] + Lambda[3]] + (q^5+2*q^4+q^3)*B[Lambda[1]
+ Lambda[3]] + (q^3+q^2)*B[2*Lambda[1] + Lambda[3]] + (q^4+q^3+q^2)*B[Lambda[2]
+ Lambda[3]] + B[2*Lambda[2] + Lambda[3]] + (q^6+q^5+q^4)*B[Lambda[3]]
TESTS:
sage: RC = RiggedConfigurations(['A', 2, 1], [[1,1], [1,1]])
sage: KR = RC.tensor_product_of_kirillov_reshetikhin_crystals()
sage: RC.fermionic_formula() == KR.one_dimensional_configuration_sum()
True
sage: KT = RC.tensor_product_of_kirillov_reshetikhin_tableaux()
sage: RC.fermionic_formula() == KT.one_dimensional_configuration_sum()
True
sage: RC = RiggedConfigurations(['C', 2, 1], [[2,1], [2,1]])
sage: KR = RC.tensor_product_of_kirillov_reshetikhin_crystals()
sage: RC.fermionic_formula() == KR.one_dimensional_configuration_sum() # long time
True
sage: t = QQ['t'].gen(0)
sage: RC = RiggedConfigurations(['D', 4, 1], [[1,1], [2,1]])
sage: KR = RC.tensor_product_of_kirillov_reshetikhin_crystals()
sage: RC.fermionic_formula(t) == KR.one_dimensional_configuration_sum(t) # long time
True
Sets and displays the global options for rigged configurations. If no parameters are set, then the function returns a copy of the options dictionary.
The options to partitions can be accessed as the method RiggedConfigurations.global_options of RiggedConfigurations.
OPTIONS:
EXAMPLES:
sage: RC = RiggedConfigurations(['A',3,1], [[2,2],[1,1],[1,1]])
sage: elt = RC(partition_list=[[3,1], [3], [1]])
sage: elt
-3[ ][ ][ ]-3
-1[ ]-1
1[ ][ ][ ]1
-1[ ]-1
sage: RiggedConfigurations.global_options(display="horizontal", convention="french")
sage: elt
-1[ ]-1 1[ ][ ][ ]1 -1[ ]-1
-3[ ][ ][ ]-3
Changing the convention for rigged configurations also changes the convention option for tableaux and vice versa:
sage: T = Tableau([[1,2,3],[4,5]])
sage: T.pp()
4 5
1 2 3
sage: Tableaux.global_options(convention="english")
sage: elt
-3[ ][ ][ ]-3 1[ ][ ][ ]1 -1[ ]-1
-1[ ]-1
sage: T.pp()
1 2 3
4 5
sage: RiggedConfigurations.global_options.reset()
See GlobalOptions for more features of these options.
Return the underlying Kleber tree used to generate all highest weight rigged configurations.
EXAMPLES:
sage: RC = RiggedConfigurations(['A',3,1], [[1,1], [2,1]])
sage: RC.kleber_tree()
Kleber tree of Cartan type ['A', 3, 1] and B = ((1, 1), (2, 1))
Module generators for this set of rigged configurations.
Iterate over the highest weight rigged configurations by moving through the KleberTree and then setting appropriate values of the partitions.
EXAMPLES:
sage: RC = RiggedConfigurations(['D', 4, 1], [[2,1]])
sage: for x in RC.module_generators: x
(/)
(/)
(/)
(/)
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0
Return the corresponding tensor product of Kirillov-Reshetikhin crystals.
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3,1],[2,2]])
sage: RC.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)]
Return the corresponding tensor product of Kirillov-Reshetikhin tableaux.
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2]])
sage: RC.tensor_product_of_kirillov_reshetikhin_tableaux()
Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and factor(s) ((3, 2), (1, 2))