A rigged configuration element is a sequence of RiggedPartition objects.
AUTHORS:
Bases: sage.combinat.rigged_configurations.rigged_configuration_element.KRRiggedConfigurationElement, sage.combinat.rigged_configurations.rigged_configuration_element.RCNonSimplyLacedElement
rigged configurations in non-simply-laced
types.
TESTS:
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: TestSuite(elt).run()
Compute the cocharge statistic.
Computes the cocharge statistic [OSS03] on this
rigged configuration by computing the cocharge as a virtual
rigged configuration
and then using the
identity
.
EXAMPLES:
sage: RC = RiggedConfigurations(['C', 3, 1], [[2,1], [1,1]])
sage: RC(partition_list=[[1,1],[2,1],[1,1]]).cocharge()
1
Compute the cocharge statistic.
Computes the cocharge statistic [OSS03] on this
rigged configuration by computing the cocharge as a virtual
rigged configuration
and then using the
identity
.
EXAMPLES:
sage: RC = RiggedConfigurations(['C', 3, 1], [[2,1], [1,1]])
sage: RC(partition_list=[[1,1],[2,1],[1,1]]).cocharge()
1
Return the action of on self.
This works by lifting into the virtual configuration, then applying
and pulling back.
EXAMPLES:
sage: RC = RiggedConfigurations(['A',6,2], [[1,1]]*7)
sage: elt = RC(partition_list=[[1]*5,[2,1,1],[3,2]])
sage: elt.e(3)
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ][ ]0
1[ ]1
1[ ]1
1[ ][ ]1
1[ ]0
Return the action of on self.
This works by lifting into the virtual configuration, then applying
and pulling back.
EXAMPLES:
sage: RC = RiggedConfigurations(['A',6,2], [[1,1]]*7)
sage: elt = RC(partition_list=[[1]*5,[2,1,1],[2,1]], rigging_list=[[0]*5,[0,1,1],[1,0]])
sage: elt.f(3)
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0
1[ ][ ]1
1[ ]1
1[ ]1
-1[ ][ ][ ]-1
0[ ][ ]0
Bases: sage.combinat.rigged_configurations.rigged_configuration_element.KRRiggedConfigurationElement
rigged configurations in simply-laced types.
TESTS:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [2,1], [1,1]])
sage: elt = RC(partition_list=[[1], [1], []]); elt
0[ ]0
0[ ]0
(/)
sage: TestSuite(elt).run()
Compute the cocharge statistic of self.
Computes the cocharge statistic [CrysStructSchilling06] on this
rigged configuration . The cocharge statistic is defined as:
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [2,1], [1,1]])
sage: RC(partition_list=[[1], [1], []]).cocharge()
1
Compute the charge statistic of self.
Let denote a set of rigged configurations. The charge
of
a rigged configuration
is computed as
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [2,1], [1,1]])
sage: RC(partition_list=[[],[],[]]).charge()
2
sage: RC(partition_list=[[1], [1], []]).charge()
1
Compute the cocharge statistic of self.
Computes the cocharge statistic [CrysStructSchilling06] on this
rigged configuration . The cocharge statistic is defined as:
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [2,1], [1,1]])
sage: RC(partition_list=[[1], [1], []]).cocharge()
1
Bases: sage.combinat.rigged_configurations.rigged_configuration_element.KRRCNonSimplyLacedElement
rigged configurations in type
.
Compute the cocharge statistic.
Computes the cocharge statistic [RigConBijection] on this
rigged configuration . The cocharge statistic is
computed as:
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[1,1],[2,2]])
sage: sc = RC.cartan_type().as_folding().scaling_factors()
sage: all(mg.cocharge() * sc[0] == mg.to_virtual_configuration().cocharge()
....: for mg in RC.module_generators)
True
Compute the cocharge statistic.
Computes the cocharge statistic [RigConBijection] on this
rigged configuration . The cocharge statistic is
computed as:
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[1,1],[2,2]])
sage: sc = RC.cartan_type().as_folding().scaling_factors()
sage: all(mg.cocharge() * sc[0] == mg.to_virtual_configuration().cocharge()
....: for mg in RC.module_generators)
True
Return the value of of self.
Here we need to modify the usual definition by
.
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[1,1], [2,2]])
sage: def epsilon(x, i):
....: x = x.e(i)
....: eps = 0
....: while x is not None:
....: x = x.e(i)
....: eps = eps + 1
....: return eps
sage: all(epsilon(rc, 2) == rc.epsilon(2) for rc in RC)
True
Return the value of of self.
Here we need to modify the usual definition by
.
EXAMPLES:
sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[1,1], [2,2]])
sage: def phi(x, i):
....: x = x.f(i)
....: ph = 0
....: while x is not None:
....: x = x.f(i)
....: ph = ph + 1
....: return ph
sage: all(phi(rc, 2) == rc.phi(2) for rc in RC)
True
Bases: sage.combinat.rigged_configurations.rigged_configuration_element.RiggedConfigurationElement
rigged configurations.
EXAMPLES:
We can go between rigged configurations and tensor products of tensor products of KR tableaux:
sage: RC = RiggedConfigurations(['D', 4, 1], [[1,1], [2,1]])
sage: rc_elt = RC(partition_list=[[1], [1,1], [1], [1]])
sage: tp_krtab = rc_elt.to_tensor_product_of_kirillov_reshetikhin_tableaux(); tp_krtab
[[-2]] (X) [[1], [2]]
sage: tp_krcrys = rc_elt.to_tensor_product_of_kirillov_reshetikhin_crystals(); tp_krcrys
[[[-2]], [[1], [2]]]
sage: tp_krcrys == tp_krtab.to_tensor_product_of_kirillov_reshetikhin_crystals()
True
sage: RC(tp_krcrys) == rc_elt
True
sage: RC(tp_krtab) == rc_elt
True
sage: tp_krtab.to_rigged_configuration() == rc_elt
True
Make sure all of the riggings are less than or equal to the vacancy number.
TESTS:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 1]])
sage: elt = RC(partition_list=[[1], [1], [], []])
sage: elt.check()
Return the classical weight of self.
The classical weight of a rigged configuration is
EXAMPLES:
sage: RC = RiggedConfigurations(['D',4,1], [[2,2]])
sage: elt = RC(partition_list=[[2],[2,1],[1],[1]])
sage: elt.classical_weight()
(0, 1, 1, 0)
This agrees with the corresponding classical weight as KR tableaux:
sage: krt = elt.to_tensor_product_of_kirillov_reshetikhin_tableaux(); krt
[[2, 1], [3, -1]]
sage: krt.classical_weight() == elt.classical_weight()
True
TESTS:
We check the classical weights agree in an entire crystal:
sage: RC = RiggedConfigurations(['A',2,1], [[2,1], [1,1]])
sage: for x in RC:
....: y = x.to_tensor_product_of_kirillov_reshetikhin_tableaux()
....: assert x.classical_weight() == y.classical_weight()
Apply the complement rigging morphism to self.
Consider a highest weight rigged configuration , the
complement rigging morphism
is given by
sending
, where
is obtained by
taking the coriggings
, and then extending as
a crystal morphism. (The name comes from taking the complement
partition for the riggings in a
box.)
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['D',4,1], [[1,1],[2,2]])
sage: mg = RC.module_generators[-1]
sage: ascii_art(mg)
1[ ][ ]1 0[ ][ ]0 0[ ][ ]0 0[ ][ ]0
0[ ][ ]0
sage: ascii_art(mg.complement_rigging())
1[ ][ ]0 0[ ][ ]0 0[ ][ ]0 0[ ][ ]0
0[ ][ ]0
sage: lw = mg.to_lowest_weight([1,2,3,4])[0]
sage: ascii_art(lw)
-1[ ][ ]-1 0[ ][ ]0 0[ ][ ]0 0[ ][ ]0
-1[ ]-1 0[ ][ ]0 0[ ]0 0[ ]0
-1[ ]-1 0[ ]0
0[ ]0
sage: ascii_art(lw.complement_rigging())
-1[ ][ ][ ]-1 0[ ][ ][ ]0 0[ ][ ][ ]0 0[ ][ ][ ]0
-1[ ]-1 0[ ][ ][ ]0
sage: lw.complement_rigging() == mg.complement_rigging().to_lowest_weight([1,2,3,4])[0]
True
sage: mg.complement_rigging(True).parent()
Rigged configurations of type ['D', 4, 1] and factor(s) ((2, 2), (1, 1))
We check that the Lusztig involution (under the modification of also
mapping to the highest weight element) intertwines with the
complement map (that reverses the tensor factors)
under the bijection
:
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 2], [2, 1], [1, 2]])
sage: for mg in RC.module_generators: # long time
....: y = mg.to_tensor_product_of_kirillov_reshetikhin_tableaux()
....: hw = y.lusztig_involution().to_highest_weight([1,2,3,4])[0]
....: c = mg.complement_rigging(True)
....: hwc = c.to_tensor_product_of_kirillov_reshetikhin_tableaux()
....: assert hw == hwc
Return the image of self under the left box removal map .
The map (if
, then we remove the left-most factor) is the
basic map in the bijection
between rigged configurations and
tensor products of Kirillov-Reshetikhin tableaux. For more
information, see
to_tensor_product_of_kirillov_reshetikhin_tableaux().
We can extend
when the left-most factor is not a single
column by precomposing with a left_split().
Note
Due to the special nature of the bijection for the spinor cases in
types ,
, and
, this map is
not defined in these cases.
INPUT:
OUTPUT:
The resulting rigged configuration or if return_b is True, then a tuple of the resulting rigged configuration and the letter.
EXAMPLES:
sage: RC = RiggedConfigurations(['C',4,1], [[3,2]])
sage: mg = RC.module_generators[-1]
sage: ascii_art(mg)
0[ ][ ]0 0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ]0
sage: ascii_art(mg.left_box())
0[ ]0 0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ]0 0[ ][ ]0 0[ ]0
sage: x,b = mg.left_box(True)
sage: b
-1
sage: b.parent()
The crystal of letters for type ['C', 4]
Return the action of the crystal operator on self.
For the classical operators, this implements the method defined
in [CrysStructSchilling06]. For , this converts the class to
a tensor product of KR tableaux and does the corresponding
and pulls back.
Todo
Implement without appealing to tensor product of
KR tableaux.
INPUT:
OUTPUT:
The resulting rigged configuration element.
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2,1]])
sage: elt = RC(partition_list=[[1], [1], [1], [1]])
sage: elt.e(3)
sage: elt.e(1)
(/)
0[ ]0
0[ ]0
-1[ ]-1
Return of self.
EXAMPLES:
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 2]])
sage: I = RC.index_set()
sage: matrix([[mg.epsilon(i) for i in I] for mg in RC.module_generators])
[4 0 0 0 0]
[3 0 0 0 0]
[2 0 0 0 0]
Return the action of the crystal operator on self.
For the classical operators, this implements the method defined
in [CrysStructSchilling06]. For , this converts the class to
a tensor product of KR tableaux and does the corresponding
and pulls back.
Todo
Implement without appealing to tensor product of
KR tableaux.
INPUT:
OUTPUT:
The resulting rigged configuration element.
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2,1]])
sage: elt = RC(partition_list=[[1], [1], [1], [1]])
sage: elt.f(1)
sage: elt.f(2)
0[ ]0
-1[ ]-1
-1[ ]-1
1[ ]1
-1[ ]-1
Return the image of self under the left box removal map .
The map (if
, then we remove the left-most factor) is the
basic map in the bijection
between rigged configurations and
tensor products of Kirillov-Reshetikhin tableaux. For more
information, see
to_tensor_product_of_kirillov_reshetikhin_tableaux().
We can extend
when the left-most factor is not a single
column by precomposing with a left_split().
Note
Due to the special nature of the bijection for the spinor cases in
types ,
, and
, this map is
not defined in these cases.
INPUT:
OUTPUT:
The resulting rigged configuration or if return_b is True, then a tuple of the resulting rigged configuration and the letter.
EXAMPLES:
sage: RC = RiggedConfigurations(['C',4,1], [[3,2]])
sage: mg = RC.module_generators[-1]
sage: ascii_art(mg)
0[ ][ ]0 0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ]0
sage: ascii_art(mg.left_box())
0[ ]0 0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ]0 0[ ][ ]0 0[ ]0
sage: x,b = mg.left_box(True)
sage: b
-1
sage: b.parent()
The crystal of letters for type ['C', 4]
Return the image of self under the left column splitting
map .
Consider the map for
which is a natural classical
crystal injection. On rigged configurations, the map
does
nothing (except possibly changing the vacancy numbers).
EXAMPLES:
sage: RC = RiggedConfigurations(['C',4,1], [[3,3]])
sage: mg = RC.module_generators[-1]
sage: ascii_art(mg)
0[ ][ ]0 0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ]0
sage: ascii_art(mg.left_split())
0[ ][ ]0 0[ ][ ]0 1[ ][ ]0 0[ ]0
0[ ][ ]0 1[ ][ ]0 0[ ]0
1[ ][ ]0 0[ ]0
Return of self.
EXAMPLES:
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 2]])
sage: I = RC.index_set()
sage: matrix([[mg.phi(i) for i in I] for mg in RC.module_generators])
[0 0 2 0 0]
[1 0 1 0 0]
[2 0 0 0 0]
Return the image of self under the right column splitting
map .
Let denote the
complement rigging map which reverses
the tensor factors and
denote the
left splitting map, we define the right
splitting map by
.
EXAMPLES:
sage: RC = RiggedConfigurations(['C',4,1], [[3,3]])
sage: mg = RC.module_generators[-1]
sage: ascii_art(mg)
0[ ][ ]0 0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ][ ]0 0[ ]0
0[ ][ ]0 0[ ]0
sage: ascii_art(mg.right_split())
0[ ][ ]0 0[ ][ ]0 1[ ][ ]1 0[ ]0
0[ ][ ]0 1[ ][ ]1 0[ ]0
1[ ][ ]1 0[ ]0
sage: RC = RiggedConfigurations(['D',4,1], [[2,2],[1,2]])
sage: elt = RC(partition_list=[[3,1], [2,2,1], [2,1], [2]])
sage: ascii_art(elt)
-1[ ][ ][ ]-1 0[ ][ ]0 -1[ ][ ]-1 1[ ][ ]1
0[ ]0 0[ ][ ]0 -1[ ]-1
0[ ]0
sage: ascii_art(elt.right_split())
-1[ ][ ][ ]-1 0[ ][ ]0 -1[ ][ ]-1 1[ ][ ]1
1[ ]0 0[ ][ ]0 -1[ ]-1
0[ ]0
We check that the bijection commutes with the right spliting map:
sage: RC = RiggedConfigurations(['A', 3, 1], [[1,1], [2,2]])
sage: all(rc.right_split().to_tensor_product_of_kirillov_reshetikhin_tableaux()
....: == rc.to_tensor_product_of_kirillov_reshetikhin_tableaux().right_split() for rc in RC)
True
Return the corresponding tensor product of Kirillov-Reshetikhin crystals.
This is a composition of the map to a tensor product of KR tableaux, and then to a tensor product of KR crystals.
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 2]])
sage: elt = RC(partition_list=[[2], [2,2], [1], [1]])
sage: krc = elt.to_tensor_product_of_kirillov_reshetikhin_crystals(); krc
[[[2, 3], [3, -2]]]
We can recover the rigged configuration:
sage: ret = RC(krc); ret
0[ ][ ]0
-2[ ][ ]-2
-2[ ][ ]-2
0[ ]0
0[ ]0
sage: elt == ret
True
We can also construct and display a graph of the bijection as follows:
sage: ret, G = elt.to_tensor_product_of_kirillov_reshetikhin_crystals(build_graph=True)
sage: view(G, tightpage=True) # not tested
Perform the bijection from this rigged configuration to a tensor product of Kirillov-Reshetikhin tableaux given in [RigConBijection] for single boxes and with [BijectionLRT] and [BijectionDn] for multiple columns and rows.
Note
This is only proven to be a bijection in types
and
, as well as
and
for general affine types.
INPUT:
OUTPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]])
sage: RC(partition_list=[[2], [2,2], [2], [2]]).to_tensor_product_of_kirillov_reshetikhin_tableaux()
[[3, 3], [5, 5]]
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 2]])
sage: elt = RC(partition_list=[[2], [2,2], [1], [1]])
sage: tp_krt = elt.to_tensor_product_of_kirillov_reshetikhin_tableaux(); tp_krt
[[2, 3], [3, -2]]
This is invertible by calling to_rigged_configuration():
sage: ret = tp_krt.to_rigged_configuration(); ret
0[ ][ ]0
-2[ ][ ]-2
-2[ ][ ]-2
0[ ]0
0[ ]0
sage: elt == ret
True
To view the steps of the bijection in the output, run with the display_steps=True option:
sage: elt.to_tensor_product_of_kirillov_reshetikhin_tableaux(True)
====================
...
====================
0[ ]0
-2[ ][ ]-2
0[ ]0
0[ ]0
0[ ]0
--------------------
[[3, 2]]
--------------------
...
[[2, 3], [3, -2]]
We can also construct and display a graph of the bijection as follows:
sage: ret, G = elt.to_tensor_product_of_kirillov_reshetikhin_tableaux(build_graph=True)
sage: view(G, tightpage=True) # not tested
Return the weight of self.
EXAMPLES:
sage: RC = RiggedConfigurations(['E', 6, 1], [[2,2]])
sage: map(lambda x: x.weight(), RC.module_generators)
[-4*Lambda[0] + 2*Lambda[2], -2*Lambda[0] + Lambda[2], 0]
sage: KR = crystals.KirillovReshetikhin(['E',6,1], 2,2)
sage: map(lambda x: x.weight(), KR.module_generators) # long time
[0, -2*Lambda[0] + Lambda[2], -4*Lambda[0] + 2*Lambda[2]]
sage: RC = RiggedConfigurations(['D', 6, 1], [[4,2]])
sage: map(lambda x: x.weight(), RC.module_generators)
[-4*Lambda[0] + 2*Lambda[4], -4*Lambda[0] + Lambda[2] + Lambda[4],
-2*Lambda[0] + Lambda[4], -4*Lambda[0] + 2*Lambda[2],
-2*Lambda[0] + Lambda[2], 0]
Bases: sage.combinat.rigged_configurations.rigged_configuration_element.RCNonSimplyLacedElement
Rigged configurations in highest weight crystals.
TESTS:
sage: La = RootSystem(['C',2,1]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(['C',2,1], La[0])
sage: elt = RC(partition_list=[[1,1],[2],[2]]); ascii_art(elt)
-1[ ]-1 2[ ][ ]2 -2[ ][ ]-2
-1[ ]-1
sage: TestSuite(elt).run()
Make sure all of the riggings are less than or equal to the vacancy number.
TESTS:
sage: La = RootSystem(['C',2,1]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(['C',2,1], La[0])
sage: elt = RC(partition_list=[[1,1],[2],[2]])
sage: elt.check()
Return the action of on self.
This works by lifting into the virtual configuration, then applying
and pulling back.
EXAMPLES:
sage: La = RootSystem(['C',2,1]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(['C',2,1], La[0])
sage: elt = RC(partition_list=[[1,1],[2],[2]])
sage: elt.f(0)
sage: ascii_art(elt.f(1))
0[ ]0 0[ ][ ]0 -1[ ][ ]-1
0[ ]0 -1[ ]-1
sage: elt.f(2)
Bases: sage.combinat.rigged_configurations.rigged_configuration_element.RiggedConfigurationElement
Rigged configurations in highest weight crystals.
TESTS:
sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(['A',2,1], La[0])
sage: elt = RC(partition_list=[[1,1],[1],[2]]); elt
-1[ ]-1
-1[ ]-1
1[ ]1
-1[ ][ ]-1
sage: TestSuite(elt).run()
Make sure all of the riggings are less than or equal to the vacancy number.
TESTS:
sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(['A',2,1], La[0])
sage: elt = RC(partition_list=[[1,1],[1],[2]])
sage: elt.check()
Return the action of the crystal operator on self.
This implements the method defined in [CrysStructSchilling06] which
finds the value which is the length of the string with the
smallest nonpositive rigging of largest length. Then it adds a box
from a string of length
in the
-th rigged partition, keeping
all colabels fixed and decreasing the new label by one. If no such
string exists, then it adds a new string of length 1 with label
.
If any of the resulting vacancy numbers are larger than the labels
(i.e. it is an invalid rigged configuration), then
is
undefined.
INPUT:
OUTPUT:
The resulting rigged configuration element.
EXAMPLES:
sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(['A',2,1], La[0])
sage: elt = RC(partition_list=[[1,1],[1],[2]])
sage: elt.f(0)
-2[ ][ ]-2
-1[ ]-1
1[ ]1
0[ ][ ]0
sage: elt.f(1)
0[ ]0
0[ ]0
-1[ ]-1
-1[ ]-1
0[ ][ ]0
sage: elt.f(2)
Bases: sage.combinat.rigged_configurations.rigged_configuration_element.RiggedConfigurationElement
Rigged configuration elements for non-simply-laced types.
TESTS:
sage: RC = crystals.infinity.RiggedConfigurations(['C',2,1])
sage: elt = RC.module_generators[0].f_string([1,0,2,2,0,1]); elt
-2[ ][ ]-1
-2[ ]-1
-2[ ]-1
-2[ ][ ]-1
sage: TestSuite(elt).run()
Return the action of on self.
This works by lifting into the virtual configuration, then applying
and pulling back.
EXAMPLES:
sage: RC = crystals.infinity.RiggedConfigurations(['C',2,1])
sage: elt = RC(partition_list=[[2],[1,1],[2]], rigging_list=[[-1],[-1,-1],[-1]])
sage: ascii_art(elt.e(0))
0[ ]0 -2[ ]-1 -2[ ][ ]-1
-2[ ]-1
sage: ascii_art(elt.e(1))
-3[ ][ ]-2 0[ ]1 -3[ ][ ]-2
sage: ascii_art(elt.e(2))
-2[ ][ ]-1 -2[ ]-1 0[ ]0
-2[ ]-1
Return the action of on self.
This works by lifting into the virtual configuration, then applying
and pulling back.
EXAMPLES:
sage: RC = crystals.infinity.RiggedConfigurations(['C',2,1])
sage: elt = RC(partition_list=[[2],[1,1],[2]], rigging_list=[[-1],[-1,-1],[-1]])
sage: ascii_art(elt.f(0))
-4[ ][ ][ ]-2 -2[ ]-1 -2[ ][ ]-1
-2[ ]-1
sage: ascii_art(elt.f(1))
-1[ ][ ]0 -2[ ][ ]-2 -1[ ][ ]0
-2[ ]-1
sage: ascii_art(elt.f(2))
-2[ ][ ]-1 -2[ ]-1 -4[ ][ ][ ]-2
-2[ ]-1
Return the corresponding rigged configuration in the virtual crystal.
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: elt.to_virtual_configuration()
0[ ][ ][ ]0
0[ ][ ][ ][ ]0
0[ ][ ][ ]0
Bases: sage.structure.list_clone.ClonableArray
A rigged configuration for simply-laced types.
For more information on rigged configurations, see RiggedConfigurations. For rigged configurations for non-simply-laced types, use RCNonSimplyLacedElement.
Typically to create a specific rigged configuration, the user will pass in the optional argument partition_list and if the user wants to specify the rigging values, give the optional argument rigging_list as well. If rigging_list is not passed, the rigging values are set to the corresponding vacancy numbers.
INPUT:
There are two optional arguments to explicitly construct a rigged configuration. The first is partition_list which gives a list of partitions, and the second is rigging_list which is a list of corresponding lists of riggings. If only partition_list is specified, then it sets the rigging equal to the calculated vacancy numbers.
If we are constructing a rigged configuration from a rigged configuration (say of another type) and we don’t want to recompute the vacancy numbers, we can use the use_vacancy_numbers to avoid the recomputation.
EXAMPLES:
Type examples:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]])
sage: RC(partition_list=[[2], [2, 2], [2], [2]])
0[ ][ ]0
-2[ ][ ]-2
-2[ ][ ]-2
2[ ][ ]2
-2[ ][ ]-2
sage: RC = RiggedConfigurations(['A', 4, 1], [[1, 1], [1, 1]])
sage: RC(partition_list=[[], [], [], []])
(/)
(/)
(/)
(/)
Type examples:
sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 2]])
sage: RC(partition_list=[[3], [3,2], [4], [3]])
-1[ ][ ][ ]-1
1[ ][ ][ ]1
0[ ][ ]0
-3[ ][ ][ ][ ]-3
-1[ ][ ][ ]-1
sage: RC = RiggedConfigurations(['D', 4, 1], [[1, 1], [2, 1]])
sage: RC(partition_list=[[1], [1,1], [1], [1]])
1[ ]1
0[ ]0
0[ ]0
0[ ]0
0[ ]0
sage: elt = RC(partition_list=[[1], [1,1], [1], [1]], rigging_list=[[0], [0,0], [0], [0]]); elt
1[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0
sage: from sage.combinat.rigged_configurations.rigged_partition import RiggedPartition
sage: RC2 = RiggedConfigurations(['D', 5, 1], [[2, 1], [3, 1]])
sage: l = [RiggedPartition()] + list(elt)
sage: ascii_art(RC2(*l))
(/) 1[ ]0 0[ ]0 0[ ]0 0[ ]0
0[ ]0
sage: ascii_art(RC2(*l, use_vacancy_numbers=True))
(/) 1[ ]0 0[ ]0 0[ ]0 0[ ]0
0[ ]0
Check the rigged configuration is properly defined.
There is nothing to check here.
EXAMPLES:
sage: RC = crystals.infinity.RiggedConfigurations(['A', 4])
sage: b = RC.module_generators[0].f_string([1,2,1,1,2,4,2,3,3,2])
sage: b.check()
Return the action of the crystal operator on self.
This implements the method defined in [CrysStructSchilling06] which
finds the value which is the length of the string with the
smallest negative rigging of smallest length. Then it removes a box
from a string of length
in the
-th rigged partition, keeping all
colabels fixed and increasing the new label by one. If no such string
exists, then
is undefined.
INPUT:
OUTPUT:
The resulting rigged configuration element.
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2,1]])
sage: elt = RC(partition_list=[[1], [1], [1], [1]])
sage: elt.e(3)
sage: elt.e(1)
(/)
0[ ]0
0[ ]0
-1[ ]-1
Return of self.
Let be the smallest string of
or
if
, then we have
.
EXAMPLES:
sage: La = RootSystem(['B',2]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(La[1]+La[2])
sage: I = RC.index_set()
sage: matrix([[rc.epsilon(i) for i in I] for rc in RC[:4]])
[0 0]
[1 0]
[0 1]
[0 2]
Return the action of the crystal operator on self.
This implements the method defined in [CrysStructSchilling06] which
finds the value which is the length of the string with the
smallest nonpositive rigging of largest length. Then it adds a box from
a string of length
in the
-th rigged partition, keeping all
colabels fixed and decreasing the new label by one. If no such string
exists, then it adds a new string of length 1 with label
. However
we need to modify the definition to work for
by removing
the condition that the resulting rigged configuration is valid.
INPUT:
OUTPUT:
The resulting rigged configuration element.
EXAMPLES:
sage: RC = crystals.infinity.RiggedConfigurations(['A', 3])
sage: nu0 = RC.module_generators[0]
sage: nu0.f(2)
(/)
-2[ ]-1
(/)
Return the vacancy number .
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]])
sage: elt = RC(partition_list=[[1], [2,1], [1], []])
sage: elt.get_vacancy_number(2, 3)
sage: elt.get_vacancy_number(2, 2)
-2
sage: elt.get_vacancy_number(2, 1)
-1
Return the list of all vacancy numbers of the rigged partition
(with duplicates).
INPUT:
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]])
sage: RC(partition_list=[[1], [2,1], [1], []]).get_vacancy_numbers(2)
[-2, -1]
Return the list of rigged partitions of this rigged
configuration element.
OUTPUT:
The array as a list.
EXAMPLES:
sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]])
sage: RC(partition_list=[[2], [2,2], [2], [2]]).nu()
[0[ ][ ]0
, -2[ ][ ]-2
-2[ ][ ]-2
, 2[ ][ ]2
, -2[ ][ ]-2
]
Return the list of partitions and the associated list of riggings of self.
EXAMPLES:
sage: RC = RiggedConfigurations(['A',3,1], [[1,2],[2,2]])
sage: rc = RC(partition_list=[[2],[1],[1]], rigging_list=[[-1],[0],[-1]]); rc
-1[ ][ ]-1
1[ ]0
-1[ ]-1
sage: rc.partition_rigging_lists()
[[[2], [1], [1]], [[-1], [0], [-1]]]
Return of self.
Let be the smallest string of
or
if
, then we have
.
EXAMPLES:
sage: La = RootSystem(['B',2]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(La[1]+La[2])
sage: I = RC.index_set()
sage: matrix([[rc.phi(i) for i in I] for rc in RC[:4]])
[1 1]
[0 3]
[0 2]
[1 1]