def KRTToRCBijection(tp_krt):
r"""
Return the correct KR tableaux to rigged configuration bijection helper class.
TESTS::
sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A', 4, 1], [[2,1]])
sage: from sage.combinat.rigged_configurations.bijection import KRTToRCBijection
sage: bijection = KRTToRCBijection(KRT(pathlist=[[5,2]]))
"""
ct = tp_krt.cartan_type()
typ = ct.type()
if ct.is_untwisted_affine():
if typ == 'A':
return KRTToRCBijectionTypeA(tp_krt)
if typ == 'B':
return KRTToRCBijectionTypeB(tp_krt)
if typ == 'C':
return KRTToRCBijectionTypeC(tp_krt)
if typ == 'D':
return KRTToRCBijectionTypeD(tp_krt)
if typ == 'E':
if ct.classical().rank() < 8:
return KRTToRCBijectionTypeE67(tp_krt)
#if typ == 'F':
#if typ == 'G':
else:
if typ == 'BC': # A_{2n}^{(2)}
return KRTToRCBijectionTypeA2Even(tp_krt)
typ = ct.dual().type()
if typ == 'BC': # A_{2n}^{(2)\dagger}
return KRTToRCBijectionTypeA2Dual(tp_krt)
if typ == 'B': # A_{2n-1}^{(2)}
return KRTToRCBijectionTypeA2Odd(tp_krt)
if typ == 'C': # D_{n+1}^{(2)}
return KRTToRCBijectionTypeDTwisted(tp_krt)
#if typ == 'F': # E_6^{(2)}
if typ == 'G': # D_4^{(3)}
return KRTToRCBijectionTypeDTri(tp_krt)
raise NotImplementedError
def run(self, verbose=False):
"""
Run the bijection from a tensor product of KR tableaux to a rigged
configuration.
INPUT:
- ``tp_krt`` -- A tensor product of KR tableaux
- ``verbose`` -- (Default: ``False``) Display each step in the
bijection
EXAMPLES::
sage: from sage.combinat.rigged_configurations.bij_type_B import KRTToRCBijectionTypeB
sage: KRT = TensorProductOfKirillovReshetikhinTableaux(['B', 3, 1], [[2, 1]])
sage: KRTToRCBijectionTypeB(KRT(pathlist=[[0,3]])).run()
<BLANKLINE>
0[ ]0
<BLANKLINE>
-1[ ]-1
-1[ ]-1
<BLANKLINE>
0[]0
<BLANKLINE>
sage: KRT = TensorProductOfKirillovReshetikhinTableaux(['B', 3, 1], [[3, 1]])
sage: KRTToRCBijectionTypeB(KRT(pathlist=[[-2,3,1]])).run()
<BLANKLINE>
(/)
<BLANKLINE>
-1[ ]-1
<BLANKLINE>
0[]0
<BLANKLINE>
"""
if verbose:
from sage.combinat.rigged_configurations.tensor_product_kr_tableaux_element \
import TensorProductOfKirillovReshetikhinTableauxElement
for cur_crystal in reversed(self.tp_krt):
r = cur_crystal.parent().r()
# Check if it is a spinor
if r == self.n:
# Perform the spinor bijection by converting to type A_{2n-1}^{(2)}
# doing the bijection there and pulling back
from sage.combinat.rigged_configurations.bij_type_A2_odd import KRTToRCBijectionTypeA2Odd
from sage.combinat.rigged_configurations.tensor_product_kr_tableaux import TensorProductOfKirillovReshetikhinTableaux
from sage.combinat.rigged_configurations.rigged_partition import RiggedPartition
if verbose:
print "===================="
if len(self.cur_path) == 0:
print(
repr([])
) # Special case for displaying when the rightmost factor is a spinor
else:
print(
repr(
TensorProductOfKirillovReshetikhinTableauxElement(
self.tp_krt.parent(), self.cur_path)))
print("--------------------")
print(repr(self.ret_rig_con))
print("--------------------\n")
print("Applying doubling map")
# Convert to a type A_{2n-1}^{(2)} RC
dims = self.cur_dims[:]
dims.insert(0, [r, cur_crystal.parent().s()])
KRT = TensorProductOfKirillovReshetikhinTableaux(
['A', 2 * self.n - 1, 2], dims)
# Convert the n-th partition into a regular rigged partition
self.ret_rig_con[-1] = RiggedPartition(
self.ret_rig_con[-1]._list, self.ret_rig_con[-1].rigging,
self.ret_rig_con[-1].vacancy_numbers)
bij = KRTToRCBijectionTypeA2Odd(
KRT.module_generators[0]) # Placeholder element
bij.ret_rig_con = KRT.rigged_configurations()(
*self.ret_rig_con)
bij.cur_path = self.cur_path
bij.cur_dims = self.cur_dims
for i in range(len(self.cur_dims)):
if bij.cur_dims[i][0] != self.n:
bij.cur_dims[i][1] *= 2
for i in range(self.n - 1):
for j in range(len(bij.ret_rig_con[i])):
bij.ret_rig_con[i]._list[j] *= 2
bij.ret_rig_con[i].rigging[j] *= 2
bij.ret_rig_con[i].vacancy_numbers[j] *= 2
# Perform the type A_{2n-1}^{(2)} bijection
r = cur_crystal.parent().r()
# Iterate through the columns
for col_number, cur_column in enumerate(
reversed(cur_crystal.to_array(False))):
bij.cur_path.insert(0, []) # Prepend an empty list
bij.cur_dims.insert(0, [0, 1])
# Note that we do not need to worry about iterating over columns
# (see previous note about the data structure).
for letter in reversed(cur_column):
bij.cur_dims[0][0] += 1
val = letter.value # Convert from a CrystalOfLetter to an Integer
if verbose:
print("====================")
print(
repr(
TensorProductOfKirillovReshetikhinTableauxElement(
self.tp_krt.parent(), bij.cur_path)))
print("--------------------")
print(repr(bij.ret_rig_con))
print("--------------------\n")
# Build the next state
bij.cur_path[0].insert(0,
[letter]) # Prepend the value
bij.next_state(val)
# If we've split off a column, we need to merge the current column
# to the current crystal tableau
if col_number > 0:
for i, letter_singleton in enumerate(self.cur_path[0]):
bij.cur_path[1][i].insert(0, letter_singleton[0])
bij.cur_dims[1][1] += 1
bij.cur_path.pop(0)
bij.cur_dims.pop(0)
# And perform the inverse column splitting map on the RC
for a in range(self.n):
bij._update_vacancy_nums(a)
if verbose:
print("====================")
print(
repr(
TensorProductOfKirillovReshetikhinTableauxElement(
self.tp_krt.parent(), bij.cur_path)))
print("--------------------")
print(repr(bij.ret_rig_con))
print("--------------------\n")
print("Applying halving map")
# Convert back to a type B_n^{(1)}
for i in range(len(self.cur_dims)):
if bij.cur_dims[i][0] != self.n:
bij.cur_dims[i][1] //= 2
for i in range(self.n - 1):
for j in range(len(bij.ret_rig_con[i])):
bij.ret_rig_con[i]._list[j] //= 2
bij.ret_rig_con[i].rigging[j] //= 2
bij.ret_rig_con[i].vacancy_numbers[j] //= 2
self.ret_rig_con = self.tp_krt.parent().rigged_configurations(
)(*bij.ret_rig_con)
# Make it mutable so we don't have to keep making copies, at the
# end of the bijection, we will make it immutable again
self.ret_rig_con._set_mutable()
else:
# Perform the regular type B_n^{(1)} bijection
# Iterate through the columns
for col_number, cur_column in enumerate(
reversed(cur_crystal.to_array(False))):
self.cur_path.insert(0, []) # Prepend an empty list
self.cur_dims.insert(0, [0, 1])
# Note that we do not need to worry about iterating over columns
# (see previous note about the data structure).
for letter in reversed(cur_column):
self.cur_dims[0][0] += 1
val = letter.value # Convert from a CrystalOfLetter to an Integer
if verbose:
print("====================")
print(
repr(
TensorProductOfKirillovReshetikhinTableauxElement(
self.tp_krt.parent(), self.cur_path)))
print("--------------------")
print(repr(self.ret_rig_con))
print("--------------------\n")
# Build the next state
self.cur_path[0].insert(0,
[letter]) # Prepend the value
self.next_state(val)
# If we've split off a column, we need to merge the current column
# to the current crystal tableau
if col_number > 0:
if verbose:
print("====================")
print(
repr(
TensorProductOfKirillovReshetikhinTableauxElement(
self.tp_krt.parent(), self.cur_path)))
print("--------------------")
print(repr(self.ret_rig_con))
print("--------------------\n")
print("Applying column merge")
for i, letter_singleton in enumerate(self.cur_path[0]):
self.cur_path[1][i].insert(0, letter_singleton[0])
self.cur_dims[1][1] += 1
self.cur_path.pop(0)
self.cur_dims.pop(0)
# And perform the inverse column splitting map on the RC
for a in range(self.n):
self._update_vacancy_nums(a)
self.ret_rig_con.set_immutable() # Return it to immutable
return self.ret_rig_con