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

\[\hat{e}_a = \prod_{j \in \iota(a)} 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)

0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0

0[ ][ ]0
1[ ]1
1[ ]1

1[ ][ ]1
1[ ]0
f(a)

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

This works by lifting into the virtual configuration, then applying

\[\hat{f}_a = \prod_{j \in \iota(a)} 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)

0[ ]0
0[ ]0
0[ ]0
0[ ]0
0[ ]0

1[ ][ ]1
1[ ]1
1[ ]1

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

0[ ][ ][ ]0

0[ ][ ]0
sage: elt.to_virtual_configuration()

0[ ][ ][ ]0

0[ ][ ][ ][ ]0

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.

EXAMPLES:

Type \(A_n^{(1)}\) 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 \(D_n^{(1)}\) 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: RC(partition_list=[[1], [1,1], [1], [1]], rigging_list=[[0], [0,0], [0], [0]])

1[ ]0

0[ ]0
0[ ]0

0[ ]0

0[ ]0

We can go between tensor products of KR tableaux and tensor products of KR crystals:

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

Compute the cocharge statistic of self.

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

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

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
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: passed_test = True
sage: for x in RC:
....:    y = x.to_tensor_product_of_kirillov_reshetikhin_tableaux()
....:    if x.classical_weight() != y.classical_weight():
....:        passed_test = False
....:        break
sage: passed_test
True
cocharge()

Compute the cocharge statistic of self.

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

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

EXAMPLES:

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

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.

Todo

Implement \(f_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)

(/)

0[ ]0

0[ ]0

-1[ ]-1
f(a)

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.

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)

0[ ]0

-1[ ]-1
-1[ ]-1

1[ ]1

-1[ ]-1
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

-1[ ][ ]-1

1[ ]0

-1[ ]-1

sage: rc.partition_rigging_lists()
[[[2], [1], [1]], [[-1], [0], [-1]]]
to_tensor_product_of_kirillov_reshetikhin_crystals(display_steps=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 output each step in the algorithm

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
to_tensor_product_of_kirillov_reshetikhin_tableaux(display_steps=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 output each step in the algorithm

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

0[ ][ ]0

-2[ ][ ]-2
-2[ ][ ]-2

0[ ]0

0[ ]0

sage: elt == ret
True

Previous topic

Rigged Configurations

Next topic

Tensor Product of Kirillov-Reshetikhin Tableaux

This Page