Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
r""" Bijection classes for type `D_{n+1}^{(2)}`.
Part of the (internal) classes which runs the bijection between rigged configurations and KR tableaux of type `D_{n+1}^{(2)}`.
AUTHORS:
- Travis Scrimshaw (2011-04-15): Initial version
TESTS::
sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 2], [[2,1]]) sage: from sage.combinat.rigged_configurations.bij_type_D_twisted import KRTToRCBijectionTypeDTwisted sage: bijection = KRTToRCBijectionTypeDTwisted(KRT(pathlist=[[-1,2]])) sage: TestSuite(bijection).run() sage: RC = RiggedConfigurations(['D', 4, 2], [[2, 1]]) sage: from sage.combinat.rigged_configurations.bij_type_D_twisted import RCToKRTBijectionTypeDTwisted sage: bijection = RCToKRTBijectionTypeDTwisted(RC()) sage: TestSuite(bijection).run() """
#***************************************************************************** # Copyright (C) 2011, 2012 Travis Scrimshaw <tscrim@ucdavis.edu> # # Distributed under the terms of the GNU General Public License (GPL) # # This code is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # The full text of the GPL is available at: # # http://www.gnu.org/licenses/ #*****************************************************************************
r""" Specific implementation of the bijection from KR tableaux to rigged configurations for type `D_{n+1}^{(2)}`.
This inherits from type `C_n^{(1)}` and `D_n^{(1)}` because we use the same methods in some places. """ """ Run the bijection from a tensor product of KR tableaux to a rigged configuration for type `D_{n+1}^{(2)}`.
INPUT:
- ``tp_krt`` -- A tensor product of KR tableaux
- ``verbose`` -- (Default: ``False``) Display each step in the bijection
EXAMPLES::
sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 2], [[3,1]]) sage: from sage.combinat.rigged_configurations.bij_type_D_twisted import KRTToRCBijectionTypeDTwisted sage: KRTToRCBijectionTypeDTwisted(KRT(pathlist=[[-1,3,2]])).run() <BLANKLINE> -1[ ]-1 <BLANKLINE> 0[ ]0 <BLANKLINE> 1[ ]1 <BLANKLINE> """ from sage.combinat.rigged_configurations.tensor_product_kr_tableaux_element \ import TensorProductOfKirillovReshetikhinTableauxElement
# Iterate through the columns
# Check to see if we are a spinor column print("====================") print(repr(TensorProductOfKirillovReshetikhinTableauxElement(self.tp_krt.parent(), self.cur_path))) print("--------------------") print(repr(self.ret_rig_con)) print("--------------------\n") print("Applying doubling map")
print("====================") print(repr(TensorProductOfKirillovReshetikhinTableauxElement(self.tp_krt.parent(), self.cur_path))) print("--------------------") print(repr(self.ret_rig_con)) print("--------------------\n")
# Build the next state
# Check to see if we are a spinor column print("====================") print(repr(TensorProductOfKirillovReshetikhinTableauxElement(self.tp_krt.parent(), self.cur_path))) print("--------------------") print(repr(self.ret_rig_con)) print("--------------------\n") print("Applying halving map")
# If we've split off a column, we need to merge the current column # to the current crystal tableau
# And perform the inverse column splitting map on the RC
r""" Build the next state for type `D_{n+1}^{(2)}`.
TESTS::
sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 2], [[2,1]]) sage: from sage.combinat.rigged_configurations.bij_type_D_twisted import KRTToRCBijectionTypeDTwisted sage: bijection = KRTToRCBijectionTypeDTwisted(KRT(pathlist=[[-1,2]])) sage: bijection.cur_path.insert(0, []) sage: bijection.cur_dims.insert(0, [0, 1]) sage: bijection.cur_path[0].insert(0, [2]) sage: bijection.next_state(2) """
# If it is a regular value, we follow the A_n rules self._correct_vacancy_nums()
else: max_width = 1
# Follow regular A_n rules self._correct_vacancy_nums() self._update_vacancy_nums(tableau_height-1) self._update_partition_values(tableau_height-1)
# Make the new string at n quasi-singular and p.vacancy_numbers[j] == p.rigging[j]: j += 1
# Always add a cell to the first singular value in the first # tableau we are updating. else:
# Add cells similar to type A_n but we move to the right until we # reach the value of n-1
# Special case for n # If we find a quasi-singular string first, then we are in case (Q, S) # otherwise we will find a singular string and insert 2 cells partition._list.append(1) partition.vacancy_numbers.append(None) # Go through our partition until we find a length of greater than 1 j = len(partition._list) - 1 while j >= 0 and partition._list[j] == 1: j -= 1 partition.rigging.insert(j + 1, None) width_n = 1 else: # Go through our partition until we find a length of greater than 2 partition._list[i] += 1 width_n = partition._list[i] partition.rigging[i] = None else: partition.rigging[j+1] = partition.rigging[j] # Shuffle it along j -= 1 case_QS = True partition._list[i] += 1 partition.rigging[i] = None # No need to set max_width here since we will find a singular string
# Now go back following the regular C_n (ish) rules else:
# Update the final rigged partitions
self._update_vacancy_nums(pos_val - 2) self._update_partition_values(pos_val - 2) self._update_vacancy_nums(tableau_height - 1) self._update_partition_values(tableau_height - 1)
# Make the new string quasi-singular num_rows = len(partition) for i in range(num_rows): if partition._list[i] == width_n: j = i+1 while j < num_rows and partition._list[j] == width_n \ and partition.vacancy_numbers[j] == partition.rigging[j]: j += 1 partition.rigging[j-1] -= 1 break
r""" Specific implementation of the bijection from rigged configurations to tensor products of KR tableaux for type `D_{n+1}^{(2)}`. """ """ Run the bijection from rigged configurations to tensor product of KR tableaux for type `D_{n+1}^{(2)}`.
INPUT:
- ``verbose`` -- (default: ``False``) display each step in the bijection - ``build_graph`` -- (default: ``False``) build the graph of each step of the bijection
EXAMPLES::
sage: RC = RiggedConfigurations(['D', 4, 2], [[3, 1]]) sage: x = RC(partition_list=[[],[1],[1]]) sage: from sage.combinat.rigged_configurations.bij_type_D_twisted import RCToKRTBijectionTypeDTwisted sage: RCToKRTBijectionTypeDTwisted(x).run() [[1], [3], [-2]] sage: bij = RCToKRTBijectionTypeDTwisted(x) sage: bij.run(build_graph=True) [[1], [3], [-2]] sage: bij._graph Digraph on 6 vertices """
# This is technically bad, but because the first thing we do is append # an empty list to ret_crystal_path, we correct this. We do it this # way so that we do not have to remove an empty list after the # bijection has been performed.
# Iterate over each column # Split off a new column if necessary
# Perform the corresponding splitting map on rigged configurations # All it does is update the vacancy numbers on the RC side
y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True) self._graph.append([self._graph[-1][1], (y, len(self._graph)), 'ls'])
# Check to see if we are a spinor print("====================") print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True))) print("--------------------") print(ret_crystal_path) print("--------------------\n") print("Applying doubling map")
print("====================") print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True))) print("--------------------") print(ret_crystal_path) print("--------------------\n")
# Make sure we have a crystal letter
# Check to see if we were a spinor print("====================") print(repr(self.rigged_con.parent()(*self.cur_partitions))) print("--------------------") print(ret_crystal_path) print("--------------------\n") print("Applying halving map")
self._graph.set_latex_options(format="dot2tex", edge_labels=True)
r""" Build the next state for type `D_{n+1}^{(2)}`.
TESTS::
sage: RC = RiggedConfigurations(['D', 4, 2], [[2, 1]]) sage: from sage.combinat.rigged_configurations.bij_type_D_twisted import RCToKRTBijectionTypeDTwisted sage: bijection = RCToKRTBijectionTypeDTwisted(RC(partition_list=[[2],[2,2],[2,2]])) sage: bijection.next_state(0) -1 """
# Calculate the rank and ell values
else:
# Modified version of _find_singular_string() else: # Check if it is singular as well if partition[j] != block_size: break elif partition.vacancy_numbers[j] == partition.rigging[j]: case_Q = False break
else:
# Now go back else:
else:
# Determine the new rigged configuration by removing boxes from the # selected string and then making the new string singular else: else:
row_num_bar_next = self.cur_partitions[n-1].remove_cell(ell[2*n-1]) else: else:
self._correct_vacancy_nums() vac_num = self.cur_partitions[n-1].vacancy_numbers[row_num_bar_next] self.cur_partitions[n-1].rigging[row_num_bar_next] = vac_num block_len = self.cur_partitions[n-1][row_num_bar_next] j = row_num_bar_next + 1 length = len(self.cur_partitions[n-1]) # Find the place for the quasisingular rigging while j < length and self.cur_partitions[n-1][j] == block_len \ and self.cur_partitions[n-1].rigging[j] == vac_num: j += 1 self.cur_partitions[n-1].rigging[j-1] = vac_num - 1 else:
|