Rigged Configuration Elements

A rigged configuration element is a sequence of RiggedPartition objects.

AUTHORS:

• Travis Scrimshaw (2010-09-26): Initial version
• Travis Scrimshaw (2012-10-25): Added virtual rigged confingurations

class sage.combinat.rigged_configurations.rigged_configuration_element.KRRCNonSimplyLacedElement(parent, rigged_partitions=[], **options)

Bases: sage.combinat.rigged_configurations.rigged_configuration_element.KRRiggedConfigurationElement, sage.combinat.rigged_configurations.rigged_configuration_element.RCNonSimplyLacedElement

\(U_q^{\prime}(\mathfrak{g})\) 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
<BLANKLINE>
0[ ][ ][ ]0
<BLANKLINE>
0[ ][ ]0
sage: TestSuite(elt).run()

cc()

Compute the cocharge statistic.

Computes the cocharge statistic [OSS03] on this rigged configuration \((\nu, J)\) by computing the cocharge as a virtual rigged configuration \((\hat{\nu}, \hat{J})\) and then using the identity \(cc(\hat{\nu}, \hat{J}) = \gamma_0 cc(\nu, J)\).

EXAMPLES:

sage: RC = RiggedConfigurations(['C', 3, 1], [[2,1], [1,1]])
sage: RC(partition_list=[[1,1],[2,1],[1,1]]).cocharge()
1

cocharge()

Compute the cocharge statistic.

Computes the cocharge statistic [OSS03] on this rigged configuration \((\nu, J)\) by computing the cocharge as a virtual rigged configuration \((\hat{\nu}, \hat{J})\) and then using the identity \(cc(\hat{\nu}, \hat{J}) = \gamma_0 cc(\nu, J)\).

EXAMPLES:

sage: RC = RiggedConfigurations(['C', 3, 1], [[2,1], [1,1]])
sage: RC(partition_list=[[1,1],[2,1],[1,1]]).cocharge()
1

e(a)

Return the action of \(e_a\) on self.

This works by lifting into the virtual configuration, then applying

\[e^v_a = \prod_{j \in \iota(a)} \hat{e}_j^{\gamma_j}\]

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)
<BLANKLINE>
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0
<BLANKLINE>
0[ ][ ]0
1[ ]1
1[ ]1
<BLANKLINE>
1[ ][ ]1
1[ ]0
<BLANKLINE>

f(a)

Return the action of \(f_a\) on self.

This works by lifting into the virtual configuration, then applying

\[f^v_a = \prod_{j \in \iota(a)} \hat{f}_j^{\gamma_j}\]

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)
<BLANKLINE>
0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0
<BLANKLINE>
1[ ][ ]1
1[ ]1
1[ ]1
<BLANKLINE>
-1[ ][ ][ ]-1
 0[ ][ ]0
<BLANKLINE>

class sage.combinat.rigged_configurations.rigged_configuration_element.KRRCSimplyLacedElement(parent, rigged_partitions=[], **options)

Bases: sage.combinat.rigged_configurations.rigged_configuration_element.KRRiggedConfigurationElement

\(U_q^{\prime}(\mathfrak{g})\) 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
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
(/)
<BLANKLINE>
sage: TestSuite(elt).run()

cc()

Compute the cocharge statistic of self.

Computes the cocharge statistic [CrysStructSchilling06] on this rigged configuration \((\nu, J)\). The cocharge statistic is defined as:

\[\begin{split}cc(\nu, J) = \frac{1}{2} \sum_{a, b \in I_0} \sum_{j,k > 0} \left( \alpha_a \mid \alpha_b \right) \min(j, k) m_j^{(a)} m_k^{(b)} + \sum_{a \in I} \sum_{i > 0} \left\lvert J^{(a, i)} \right\rvert.\end{split}\]

EXAMPLES:

sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [2,1], [1,1]])
sage: RC(partition_list=[[1], [1], []]).cocharge()
1

charge()

Compute the charge statistic of self.

Let \(B\) denote a set of rigged configurations. The charge \(c\) of a rigged configuration \(b\) is computed as

\[c(b) = \max(cc(b) \mid b \in B) - cc(b).\]

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

cocharge()

Compute the cocharge statistic of self.

Computes the cocharge statistic [CrysStructSchilling06] on this rigged configuration \((\nu, J)\). The cocharge statistic is defined as:

\[\begin{split}cc(\nu, J) = \frac{1}{2} \sum_{a, b \in I_0} \sum_{j,k > 0} \left( \alpha_a \mid \alpha_b \right) \min(j, k) m_j^{(a)} m_k^{(b)} + \sum_{a \in I} \sum_{i > 0} \left\lvert J^{(a, i)} \right\rvert.\end{split}\]

EXAMPLES:

sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [2,1], [1,1]])
sage: RC(partition_list=[[1], [1], []]).cocharge()
1

class sage.combinat.rigged_configurations.rigged_configuration_element.KRRCTypeA2DualElement(parent, rigged_partitions=[], **options)

Bases: sage.combinat.rigged_configurations.rigged_configuration_element.KRRCNonSimplyLacedElement

\(U_q^{\prime}(\mathfrak{g})\) rigged configurations in type \(A_{2n}^{(2)\dagger}\).

cc()

Compute the cocharge statistic.

Computes the cocharge statistic [RigConBijection] on this rigged configuration \((\nu, J)\). The cocharge statistic is computed as:

\[\begin{split}cc(\nu, J) = \frac{1}{2} \sum_{a \in I_0} \sum_{i > 0} t_a^{\vee} m_i^{(a)} \left( \sum_{j > 0} \min(i, j) L_j^{(a)} - p_i^{(a)} \right) + \sum_{a \in I} t_a^{\vee} \sum_{i > 0} \left\lvert J^{(a, i)} \right\rvert.\end{split}\]

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

cocharge()

Compute the cocharge statistic.

Computes the cocharge statistic [RigConBijection] on this rigged configuration \((\nu, J)\). The cocharge statistic is computed as:

\[\begin{split}cc(\nu, J) = \frac{1}{2} \sum_{a \in I_0} \sum_{i > 0} t_a^{\vee} m_i^{(a)} \left( \sum_{j > 0} \min(i, j) L_j^{(a)} - p_i^{(a)} \right) + \sum_{a \in I} t_a^{\vee} \sum_{i > 0} \left\lvert J^{(a, i)} \right\rvert.\end{split}\]

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

epsilon(a)

Return the value of \(\varepsilon_a\) of self.

Here we need to modify the usual definition by \(\varepsilon_n^{\prime} := 2 \varepsilon_n\).

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

phi(a)

Return the value of \(\varphi_a\) of self.

Here we need to modify the usual definition by \(\varphi_n^{\prime} := 2 \varphi_n\).

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

class sage.combinat.rigged_configurations.rigged_configuration_element.KRRiggedConfigurationElement(parent, rigged_partitions=[], **options)

Bases: sage.combinat.rigged_configurations.rigged_configuration_element.RiggedConfigurationElement

\(U_q^{\prime}(\mathfrak{g})\) 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

check()

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()

classical_weight()

Return the classical weight of self.

The classical weight \(\Lambda\) of a rigged configuration is

\[\begin{split}\Lambda = \sum_{a \in \overline{I}} \sum_{i > 0} i L_i^{(a)} \Lambda_a - \sum_{a \in \overline{I}} \sum_{i > 0} i m_i^{(a)} \alpha_a.\end{split}\]

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()

complement_rigging(reverse_factors=False)

Apply the complement rigging morphism \(\theta\) to self.

Consider a highest weight rigged configuration \((\nu, J)\), the complement rigging morphism \(\theta : RC(L) \to RC(L)\) is given by sending \((\nu, J) \mapsto (\nu, J')\), where \(J'\) is obtained by taking the coriggings \(x' = p_i^{(a)} - x\), and then extending as a crystal morphism. (The name comes from taking the complement partition for the riggings in a \(m_i^{(a)} \times p_i^{(a)}\) box.)

INPUT:

• reverse_factors – (default: False) if True, then this returns an element in \(RC(B')\) where \(B'\) is the tensor factors of self in reverse order

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 \(\theta\) (that reverses the tensor factors) under the bijection \(\Phi\):

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

delta(return_b=False)

Return the image of self under the left box removal map \(\delta\).

The map \(\delta : RC(B^{r,1} \otimes B) \to RC(B^{r-1,1} \otimes B)\) (if \(r = 1\), then we remove the left-most factor) is the basic map in the bijection \(\Phi\) between rigged configurations and tensor products of Kirillov-Reshetikhin tableaux. For more information, see to_tensor_product_of_kirillov_reshetikhin_tableaux(). We can extend \(\delta\) 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 \(D_n^{(1)}\), \(B_n^{(1)}\), and \(A_{2n-1}^{(2)}\), this map is not defined in these cases.

INPUT:

• return_b – (default: False) whether to return the resulting letter from \(\delta\)

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]

e(a)

Return the action of the crystal operator \(e_a\) on self.

For the classical operators, this implements the method defined in [CrysStructSchilling06]. For \(e_0\), this converts the class to a tensor product of KR tableaux and does the corresponding \(e_0\) and pulls back.

Todo

Implement \(e_0\) without appealing to tensor product of KR tableaux.

INPUT:

• a – the index of the partition to remove a box

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)
<BLANKLINE>
(/)
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
-1[ ]-1
<BLANKLINE>

epsilon(a)

Return \(\varepsilon_a\) 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]

f(a)

Return the action of the crystal operator \(f_a\) on self.

For the classical operators, this implements the method defined in [CrysStructSchilling06]. For \(f_0\), this converts the class to a tensor product of KR tableaux and does the corresponding \(f_0\) and pulls back.

Todo

Implement \(f_0\) without appealing to tensor product of KR tableaux.

INPUT:

• a – the index of the partition to add a box

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)
<BLANKLINE>
0[ ]0
<BLANKLINE>
-1[ ]-1
-1[ ]-1
<BLANKLINE>
1[ ]1
<BLANKLINE>
-1[ ]-1
<BLANKLINE>

left_box(return_b=False)

Return the image of self under the left box removal map \(\delta\).

The map \(\delta : RC(B^{r,1} \otimes B) \to RC(B^{r-1,1} \otimes B)\) (if \(r = 1\), then we remove the left-most factor) is the basic map in the bijection \(\Phi\) between rigged configurations and tensor products of Kirillov-Reshetikhin tableaux. For more information, see to_tensor_product_of_kirillov_reshetikhin_tableaux(). We can extend \(\delta\) 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 \(D_n^{(1)}\), \(B_n^{(1)}\), and \(A_{2n-1}^{(2)}\), this map is not defined in these cases.

INPUT:

• return_b – (default: False) whether to return the resulting letter from \(\delta\)

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]

left_split()

Return the image of self under the left column splitting map \(\beta\).

Consider the map \(\beta : RC(B^{r,s} \otimes B) \to RC(B^{r,1} \otimes B^{r,s-1} \otimes B)\) for \(s > 1\) which is a natural classical crystal injection. On rigged configurations, the map \(\beta\) 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

phi(a)

Return \(\varphi_a\) 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]

right_split()

Return the image of self under the right column splitting map \(\beta^*\).

Let \(\theta\) denote the complement rigging map which reverses the tensor factors and \(\beta\) denote the left splitting map, we define the right splitting map by \(\beta^* := \theta \circ \beta \circ \theta\).

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

to_tensor_product_of_kirillov_reshetikhin_crystals(display_steps=False, build_graph=False)

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:

• display_steps – (default: False) boolean which indicates if we want to print each step in the algorithm
• build_graph – (default: False) boolean which indicates if we want to construct and return a graph of the bijection whose vertices are rigged configurations obtained at each step and edges are labeled by either the return value of \(\delta\) or the doubling/halving map

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
<BLANKLINE>
0[ ][ ]0
<BLANKLINE>
-2[ ][ ]-2
-2[ ][ ]-2
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
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

to_tensor_product_of_kirillov_reshetikhin_tableaux(display_steps=False, build_graph=False)

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 \(A_n^{(1)}\) and \(D_n^{(1)}\), as well as \(\bigotimes_i B^{r_i,1}\) and \(\bigotimes_i B^{1,s_i}\) for general affine types.

INPUT:

• display_steps – (default: False) boolean which indicates if we want to print each step in the algorithm
• build_graph – (default: False) boolean which indicates if we want to construct and return a graph of the bijection whose vertices are rigged configurations obtained at each step and edges are labeled by either the return value of \(\delta\) or the doubling/halving map

OUTPUT:

• The tensor product of KR tableaux element corresponding to this rigged configuration.

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
<BLANKLINE>
0[ ][ ]0
<BLANKLINE>
-2[ ][ ]-2
-2[ ][ ]-2
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
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)
====================
...
====================
<BLANKLINE>
0[ ]0
<BLANKLINE>
-2[ ][ ]-2
 0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
--------------------
[[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

weight()

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]

class sage.combinat.rigged_configurations.rigged_configuration_element.RCHWNonSimplyLacedElement(parent, rigged_partitions=[], **options)

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()

check()

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()

f(a)

Return the action of \(f_a\) on self.

This works by lifting into the virtual configuration, then applying

\[f^v_a = \prod_{j \in \iota(a)} \hat{f}_j^{\gamma_j}\]

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)

class sage.combinat.rigged_configurations.rigged_configuration_element.RCHighestWeightElement(parent, rigged_partitions=[], **options)

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
<BLANKLINE>
-1[ ]-1
-1[ ]-1
<BLANKLINE>
1[ ]1
<BLANKLINE>
-1[ ][ ]-1
<BLANKLINE>
sage: TestSuite(elt).run()

check()

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()

f(a)

Return the action of the crystal operator \(f_a\) on self.

This implements the method defined in [CrysStructSchilling06] which finds the value \(k\) 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 \(k\) in the \(a\)-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 \(-1\). If any of the resulting vacancy numbers are larger than the labels (i.e. it is an invalid rigged configuration), then \(f_a\) is undefined.

INPUT:

• a – the index of the partition to add a box

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)
<BLANKLINE>
-2[ ][ ]-2
-1[ ]-1
<BLANKLINE>
1[ ]1
<BLANKLINE>
0[ ][ ]0
<BLANKLINE>
sage: elt.f(1)
<BLANKLINE>
0[ ]0
0[ ]0
<BLANKLINE>
-1[ ]-1
-1[ ]-1
<BLANKLINE>
0[ ][ ]0
<BLANKLINE>
sage: elt.f(2)

class sage.combinat.rigged_configurations.rigged_configuration_element.RCNonSimplyLacedElement(parent, rigged_partitions=[], **options)

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
<BLANKLINE>
-2[ ][ ]-1
<BLANKLINE>
-2[ ]-1
-2[ ]-1
<BLANKLINE>
-2[ ][ ]-1
<BLANKLINE>
sage: TestSuite(elt).run()

e(a)

Return the action of \(e_a\) on self.

This works by lifting into the virtual configuration, then applying

\[e^v_a = \prod_{j \in \iota(a)} \hat{e}_j^{\gamma_j}\]

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

f(a)

Return the action of \(f_a\) on self.

This works by lifting into the virtual configuration, then applying

\[f^v_a = \prod_{j \in \iota(a)} \hat{f}_j^{\gamma_j}\]

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

to_virtual_configuration()

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
<BLANKLINE>
0[ ][ ][ ]0
<BLANKLINE>
0[ ][ ]0
sage: elt.to_virtual_configuration()
<BLANKLINE>
0[ ][ ][ ]0
<BLANKLINE>
0[ ][ ][ ][ ]0
<BLANKLINE>
0[ ][ ][ ]0

class sage.combinat.rigged_configurations.rigged_configuration_element.RiggedConfigurationElement(parent, rigged_partitions=[], **options)

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:

• parent – the parent of this element
• rigged_partitions – a list of rigged partitions

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 \(A_n^{(1)}\) examples:

sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]])
sage: RC(partition_list=[[2], [2, 2], [2], [2]])
<BLANKLINE>
0[ ][ ]0
<BLANKLINE>
-2[ ][ ]-2
-2[ ][ ]-2
<BLANKLINE>
2[ ][ ]2
<BLANKLINE>
-2[ ][ ]-2
<BLANKLINE>

sage: RC = RiggedConfigurations(['A', 4, 1], [[1, 1], [1, 1]])
sage: RC(partition_list=[[], [], [], []])
<BLANKLINE>
(/)
<BLANKLINE>
(/)
<BLANKLINE>
(/)
<BLANKLINE>
(/)
<BLANKLINE>

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

sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 2]])
sage: RC(partition_list=[[3], [3,2], [4], [3]])
<BLANKLINE>
-1[ ][ ][ ]-1
<BLANKLINE>
1[ ][ ][ ]1
0[ ][ ]0
<BLANKLINE>
-3[ ][ ][ ][ ]-3
<BLANKLINE>
-1[ ][ ][ ]-1
<BLANKLINE>

sage: RC = RiggedConfigurations(['D', 4, 1], [[1, 1], [2, 1]])
sage: RC(partition_list=[[1], [1,1], [1], [1]])
<BLANKLINE>
1[ ]1
<BLANKLINE>
0[ ]0
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
sage: elt = RC(partition_list=[[1], [1,1], [1], [1]], rigging_list=[[0], [0,0], [0], [0]]); elt
<BLANKLINE>
1[ ]0
<BLANKLINE>
0[ ]0
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>

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()

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()

e(a)

Return the action of the crystal operator \(e_a\) on self.

This implements the method defined in [CrysStructSchilling06] which finds the value \(k\) 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 \(k\) in the \(a\)-th rigged partition, keeping all colabels fixed and increasing the new label by one. If no such string exists, then \(e_a\) is undefined.

INPUT:

• a – the index of the partition to remove a box

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)
<BLANKLINE>
(/)
<BLANKLINE>
0[ ]0
<BLANKLINE>
0[ ]0
<BLANKLINE>
-1[ ]-1
<BLANKLINE>

epsilon(a)

Return \(\varepsilon_a\) of self.

Let \(x_{\ell}\) be the smallest string of \(\nu^{(a)}\) or \(0\) if \(\nu^{(a)} = \emptyset\), then we have \(\varepsilon_a = -\min(0, x_{\ell})\).

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]

f(a)

Return the action of the crystal operator \(f_a\) on self.

This implements the method defined in [CrysStructSchilling06] which finds the value \(k\) 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 \(k\) in the \(a\)-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 \(-1\). However we need to modify the definition to work for \(B(\infty)\) by removing the condition that the resulting rigged configuration is valid.

INPUT:

• a – the index of the partition to add a box

OUTPUT:

The resulting rigged configuration element.

EXAMPLES:

sage: RC = crystals.infinity.RiggedConfigurations(['A', 3])
sage: nu0 = RC.module_generators[0]
sage: nu0.f(2)
<BLANKLINE>
(/)
<BLANKLINE>
-2[ ]-1
<BLANKLINE>
(/)
<BLANKLINE>

get_vacancy_number(a, i)

Return the vacancy number \(p_i^{(a)}\).

INPUT:

• a – the index of the rigged partition
• i – the row of the rigged partition

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

get_vacancy_numbers(a)

Return the list of all vacancy numbers of the rigged partition \(\nu^{(a)}\) (with duplicates).

INPUT:

• a – the index of the rigged partition

EXAMPLES:

sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]])
sage: RC(partition_list=[[1], [2,1], [1], []]).get_vacancy_numbers(2)
[-2, -1]

nu()

Return the list \(\nu\) of rigged partitions of this rigged configuration element.

OUTPUT:

The \(\nu\) 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
 ]

partition_rigging_lists()

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
<BLANKLINE>
-1[ ][ ]-1
<BLANKLINE>
1[ ]0
<BLANKLINE>
-1[ ]-1
<BLANKLINE>
sage: rc.partition_rigging_lists()
[[[2], [1], [1]], [[-1], [0], [-1]]]

phi(a)

Return \(\varphi_a\) of self.

Let \(x_{\ell}\) be the smallest string of \(\nu^{(a)}\) or \(0\) if \(\nu^{(a)} = \emptyset\), then we have \(\varepsilon_a = p_{\infty}^{(a)} - \min(0, x_{\ell})\).

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]