passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/combinat/rigged_configurations/bij_infinity.py

@@ -0,0 +1,370 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.graphs sage.modules
+r"""
+Bijection between rigged configurations for `B(\infty)` and marginally large tableaux
+
+AUTHORS:
+
+- Travis Scrimshaw (2015-07-01): Initial version
+
+REFERENCES:
+
+.. [RC-MLT] Ben Salisbury and Travis Scrimshaw. *Connecting marginally
+   large tableaux and rigged configurations via crystals*.
+   Preprint. :arxiv:`1505.07040`.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2015 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:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations
+
+from sage.combinat.rigged_configurations.bij_type_B import (KRTToRCBijectionTypeB,
+                                                            RCToKRTBijectionTypeB)
+from sage.combinat.rigged_configurations.bij_type_D import (KRTToRCBijectionTypeD,
+                                                            RCToKRTBijectionTypeD)
+from sage.combinat.rigged_configurations.bij_type_A import (KRTToRCBijectionTypeA,
+                                                            RCToKRTBijectionTypeA)
+from sage.combinat.rigged_configurations.bij_type_C import (KRTToRCBijectionTypeC,
+                                                            RCToKRTBijectionTypeC)
+from sage.combinat.rigged_configurations.tensor_product_kr_tableaux import TensorProductOfKirillovReshetikhinTableaux
+from sage.combinat.crystals.letters import CrystalOfLetters
+from sage.categories.morphism import Morphism
+from sage.categories.homset import Hom
+from sage.misc.flatten import flatten
+
+
+class FromTableauIsomorphism(Morphism):
+    r"""
+    Crystal isomorphism of `B(\infty)` in the tableau model to the
+    rigged configuration model.
+    """
+
+    def _repr_type(self):
+        r"""
+        Return the type of morphism of ``self``.
+
+        EXAMPLES::
+
+            sage: RC = crystals.infinity.RiggedConfigurations(['A',3])
+            sage: T = crystals.infinity.Tableaux(['A',3])
+            sage: phi = RC.coerce_map_from(T)
+            sage: phi._repr_type()
+            'Crystal Isomorphism'
+        """
+        return "Crystal Isomorphism"
+
+    def __invert__(self):
+        r"""
+        Return the inverse of ``self``.
+
+        EXAMPLES::
+
+            sage: RC = crystals.infinity.RiggedConfigurations(['A',3])
+            sage: T = crystals.infinity.Tableaux(['A',3])
+            sage: phi = RC.coerce_map_from(T)
+            sage: ~phi
+            Crystal Isomorphism morphism:
+              From: The infinity crystal of rigged configurations of type ['A', 3]
+              To:   The infinity crystal of tableaux of type ['A', 3]
+        """
+        return FromRCIsomorphism(Hom(self.codomain(), self.domain()))
+
+    def _call_(self, x):
+        r"""
+        Return the image of ``x`` in the rigged configuration model
+        of `B(\infty)`.
+
+        EXAMPLES::
+
+            sage: RC = crystals.infinity.RiggedConfigurations(['A',3])
+            sage: T = crystals.infinity.Tableaux(['A',3])
+            sage: phi = RC.coerce_map_from(T)
+            sage: x = T.an_element().f_string([2,2,1,1,3,2,1,2,1,3])
+            sage: y = phi(x); ascii_art(y)
+            -4[ ][ ][ ][ ]-2  -3[ ][ ][ ]-1  -1[ ][ ]-1
+                              -2[ ]-1
+            sage: (~phi)(y) == x
+            True
+        """
+        conj = x.to_tableau().conjugate()
+        ct = self.domain().cartan_type()
+        act = ct.affine()
+        TP = TensorProductOfKirillovReshetikhinTableaux(act, [[r,1] for r in conj.shape()])
+        elt = TP(pathlist=[reversed(row) for row in conj])
+
+        if ct.type() == 'A':
+            bij = KRTToRCBijectionTypeA(elt)
+        elif ct.type() == 'B':
+            bij = MLTToRCBijectionTypeB(elt)
+        elif ct.type() == 'C':
+            bij = KRTToRCBijectionTypeC(elt)
+        elif ct.type() == 'D':
+            bij = MLTToRCBijectionTypeD(elt)
+        else:
+            raise NotImplementedError("bijection of type {} not yet implemented".format(ct))
+        return self.codomain()(bij.run())
+
+
+class FromRCIsomorphism(Morphism):
+    r"""
+    Crystal isomorphism of `B(\infty)` in the rigged configuration model
+    to the tableau model.
+    """
+
+    def _repr_type(self):
+        r"""
+        Return the type of morphism of ``self``.
+
+        EXAMPLES::
+
+            sage: T = crystals.infinity.Tableaux(['A',3])
+            sage: RC = crystals.infinity.RiggedConfigurations(['A',3])
+            sage: phi = T.coerce_map_from(RC)
+            sage: phi._repr_type()
+            'Crystal Isomorphism'
+        """
+        return "Crystal Isomorphism"
+
+    def __invert__(self):
+        r"""
+        Return the inverse of ``self``.
+
+        EXAMPLES::
+
+            sage: T = crystals.infinity.Tableaux(['A',3])
+            sage: RC = crystals.infinity.RiggedConfigurations(['A',3])
+            sage: phi = T.coerce_map_from(RC)
+            sage: ~phi
+            Crystal Isomorphism morphism:
+              From: The infinity crystal of tableaux of type ['A', 3]
+              To:   The infinity crystal of rigged configurations of type ['A', 3]
+        """
+        return FromTableauIsomorphism(Hom(self.codomain(), self.domain()))
+
+    def _call_(self, x):
+        r"""
+        Return the image of ``x`` in the tableau model of `B(\infty)`.
+
+        EXAMPLES::
+
+            sage: T = crystals.infinity.Tableaux(['A',3])
+            sage: RC = crystals.infinity.RiggedConfigurations(['A',3])
+            sage: phi = T.coerce_map_from(RC)
+            sage: x = RC.an_element().f_string([2,2,1,1,3,2,1,2,1,3])
+            sage: y = phi(x); y.pp()
+              1  1  1  1  1  2  2  3  4
+              2  2  3  4
+              3
+            sage: (~phi)(y) == x
+            True
+        """
+        lam = [sum(nu)+1 for nu in x]
+        ct = self.domain().cartan_type()
+        I = ct.index_set()
+        if ct.type() == 'D':
+            lam[-2] = max(lam[-2], lam[-1])
+            lam.pop()
+            l = sum([[[r+1, 1]]*v for r, v in enumerate(lam[:-1])], [])
+            n = len(I)
+            l = l + sum([[[n,1], [n-1,1]] for k in range(lam[-1])], [])
+        else:
+            if ct.type() == 'B':
+                lam[-1] *= 2
+            l = sum([[[r, 1]]*lam[i] for i, r in enumerate(I)], [])
+
+        RC = RiggedConfigurations(ct.affine(), reversed(l))
+        elt = RC(x)
+        if ct.type() == 'A':
+            bij = RCToKRTBijectionTypeA(elt)
+        elif ct.type() == 'B':
+            bij = RCToMLTBijectionTypeB(elt)
+        elif ct.type() == 'C':
+            bij = RCToKRTBijectionTypeC(elt)
+        elif ct.type() == 'D':
+            bij = RCToMLTBijectionTypeD(elt)
+        else:
+            raise NotImplementedError("bijection of type {} not yet implemented".format(ct))
+        y = bij.run()
+
+        # Now make the result marginally large
+        y = [list(c) for c in y]
+        cur = []
+        L = CrystalOfLetters(ct)
+        for i in I:
+            cur.insert(0, L(i))
+            c = y.count(cur)
+            while c > 1:
+                y.remove(cur)
+                c -= 1
+        return self.codomain()(*flatten(y))
+
+
+class MLTToRCBijectionTypeB(KRTToRCBijectionTypeB):
+    def run(self):
+        r"""
+        Run the bijection from a marginally large tableaux to a rigged
+        configuration.
+
+        EXAMPLES::
+
+            sage: vct = CartanType(['B',4]).as_folding()
+            sage: RC = crystals.infinity.RiggedConfigurations(vct)
+            sage: T = crystals.infinity.Tableaux(['B',4])
+            sage: Psi = T.crystal_morphism({T.module_generators[0]: RC.module_generators[0]})
+            sage: TS = [x.value for x in T.subcrystal(max_depth=4)]
+            sage: all(Psi(b) == RC(b) for b in TS) # long time # indirect doctest
+            True
+        """
+        for cur_crystal in reversed(self.tp_krt):
+            cur_column = list(cur_crystal)
+            self.cur_path.insert(0, []) # Prepend an empty list
+            self.cur_dims.insert(0, [0, 1])
+
+            for letter in reversed(cur_column):
+                self.cur_dims[0][0] += 1
+
+                val = letter.value # Convert from a CrystalOfLetter to an Integer
+
+                # Build the next state
+                self.cur_path[0].insert(0, [letter]) # Prepend the value
+                if self.cur_dims[0][0] == self.n:
+                    # Spinor case, we go from \Lambda_{n-1} -> 2\Lambda_n
+                    self.cur_dims.insert(1, [self.n,1])
+                    self.cur_path.insert(1, self.cur_path[0])
+
+                self.next_state(val)
+
+        self.ret_rig_con.set_immutable() # Return it to immutable
+        return self.ret_rig_con
+
+
+class RCToMLTBijectionTypeB(RCToKRTBijectionTypeB):
+    def run(self):
+        r"""
+        Run the bijection from rigged configurations to a marginally large
+        tableau.
+
+        EXAMPLES::
+
+            sage: vct = CartanType(['B',4]).as_folding()
+            sage: RC = crystals.infinity.RiggedConfigurations(vct)
+            sage: T = crystals.infinity.Tableaux(['B',4])
+            sage: Psi = RC.crystal_morphism({RC.module_generators[0]: T.module_generators[0]})
+            sage: RCS = [x.value for x in RC.subcrystal(max_depth=4)]
+            sage: all(Psi(nu) == T(nu) for nu in RCS) # long time # indirect doctest
+            True
+        """
+        letters = CrystalOfLetters(self.rigged_con.parent()._cartan_type.classical())
+        ret_crystal_path = []
+
+        while self.cur_dims:
+            dim = self.cur_dims[0]
+            ret_crystal_path.append([])
+
+            # Assumption: all factors are single columns
+            if dim[0] == self.n:
+                # Spinor case, since we've done 2\Lambda_n -> \Lambda_{n-1}
+                self.cur_dims.pop(1)
+
+            while dim[0] > 0:
+                dim[0] -= 1 # This takes care of the indexing
+                b = self.next_state(dim[0])
+
+                # Make sure we have a crystal letter
+                ret_crystal_path[-1].append(letters(b)) # Append the rank
+
+            self.cur_dims.pop(0) # Pop off the leading column
+
+        return ret_crystal_path
+
+
+class MLTToRCBijectionTypeD(KRTToRCBijectionTypeD):
+    def run(self):
+        r"""
+        Run the bijection from a marginally large tableaux to a rigged
+        configuration.
+
+        EXAMPLES::
+
+            sage: RC = crystals.infinity.RiggedConfigurations(['D',4])
+            sage: T = crystals.infinity.Tableaux(['D',4])
+            sage: Psi = T.crystal_morphism({T.module_generators[0]: RC.module_generators[0]})
+            sage: TS = [x.value for x in T.subcrystal(max_depth=4)]
+            sage: all(Psi(b) == RC(b) for b in TS) # long time # indirect doctest
+            True
+        """
+        for cur_crystal in reversed(self.tp_krt):
+            # Iterate through the columns
+            cur_column = list(cur_crystal)
+            self.cur_path.insert(0, []) # Prepend an empty list
+
+            self.cur_dims.insert(0, [0, 1])
+
+            for letter in reversed(cur_column):
+                self.cur_dims[0][0] += 1
+
+                val = letter.value # Convert from a CrystalOfLetter to an Integer
+
+                # Build the next state
+                self.cur_path[0].insert(0, [letter]) # Prepend the value
+                self.next_state(val)
+
+                if self.cur_dims[0][0] == self.n - 1:
+                    # Spinor case, we go from \Lambda_{n-2} -> \Lambda_{n-1} + \Lambda_n
+                    self.cur_dims.insert(1, [self.n,1])
+                    self.cur_path.insert(1, self.cur_path[0] + [None])
+
+        self.ret_rig_con.set_immutable() # Return it to immutable
+        return self.ret_rig_con
+
+
+class RCToMLTBijectionTypeD(RCToKRTBijectionTypeD):
+    def run(self):
+        r"""
+        Run the bijection from rigged configurations to a marginally large
+        tableau.
+
+        EXAMPLES::
+
+            sage: RC = crystals.infinity.RiggedConfigurations(['D',4])
+            sage: T = crystals.infinity.Tableaux(['D',4])
+            sage: Psi = RC.crystal_morphism({RC.module_generators[0]: T.module_generators[0]})
+            sage: RCS = [x.value for x in RC.subcrystal(max_depth=4)]
+            sage: all(Psi(nu) == T(nu) for nu in RCS) # long time # indirect doctest
+            True
+        """
+        letters = CrystalOfLetters(self.rigged_con.parent()._cartan_type.classical())
+        ret_crystal_path = []
+
+        while self.cur_dims:
+            dim = self.cur_dims[0]
+            ret_crystal_path.append([])
+
+            # Assumption: all factors are single columns
+            if dim[0] == self.n - 1:
+                # Spinor case, since we've done \Lambda_n + \Lambda_{n-1} -> \Lambda_{n-2}
+                self.cur_dims.pop(1)
+
+            while dim[0] > 0:
+                dim[0] -= 1 # This takes care of the indexing
+                b = self.next_state(dim[0])
+
+                # Make sure we have a crystal letter
+                ret_crystal_path[-1].append(letters(b)) # Append the rank
+
+            self.cur_dims.pop(0) # Pop off the leading column
+
+        return ret_crystal_path

sage/combinat/rigged_configurations/bij_type_A.py

@@ -0,0 +1,163 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.graphs sage.modules
+r"""
+Bijection classes for type `A_n^{(1)}`
+
+Part of the (internal) classes which run the bijection between rigged
+configurations and tensor products of Kirillov-Reshetikhin tableaux of
+type `A_n^{(1)}`.
+
+AUTHORS:
+
+- Travis Scrimshaw (2011-04-15): Initial version
+
+TESTS::
+
+    sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A', 4, 1], [[2,1]])
+    sage: from sage.combinat.rigged_configurations.bij_type_A import KRTToRCBijectionTypeA
+    sage: bijection = KRTToRCBijectionTypeA(KRT(pathlist=[[5,2]]))
+    sage: TestSuite(bijection).run()
+    sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 1]])
+    sage: from sage.combinat.rigged_configurations.bij_type_A import RCToKRTBijectionTypeA
+    sage: bijection = RCToKRTBijectionTypeA(RC(partition_list=[[],[],[],[]]))
+    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:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.combinat.rigged_configurations.bij_abstract_class import KRTToRCBijectionAbstract
+from sage.combinat.rigged_configurations.bij_abstract_class import RCToKRTBijectionAbstract
+
+
+class KRTToRCBijectionTypeA(KRTToRCBijectionAbstract):
+    r"""
+    Specific implementation of the bijection from KR tableaux to rigged
+    configurations for type `A_n^{(1)}`.
+    """
+
+    def next_state(self, val):
+        r"""
+        Build the next state for type `A_n^{(1)}`.
+
+        EXAMPLES::
+
+            sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A', 4, 1], [[2,1]])
+            sage: from sage.combinat.rigged_configurations.bij_type_A import KRTToRCBijectionTypeA
+            sage: bijection = KRTToRCBijectionTypeA(KRT(pathlist=[[4,3]]))
+            sage: bijection.cur_path.insert(0, [])
+            sage: bijection.cur_dims.insert(0, [0, 1])
+            sage: bijection.cur_path[0].insert(0, [3])
+            sage: bijection.next_state(3)
+        """
+        tableau_height = len(self.cur_path[0]) - 1
+        n = self.n
+
+        # Note first we subtract off for the n = max value (in the path) - 1,
+        #   then we remove 1 to match the indices between math and programming.
+        if val - 1 > tableau_height:
+            # Always add a cell to the first singular value in the first
+            #   tableau we are updating.
+            if len(self.ret_rig_con[val - 2]) > 0:
+                max_width = self.ret_rig_con[val - 2][0]
+            else:
+                max_width = 1
+
+            # Insert a cell into the rightmost rigged partition
+            max_width = self.ret_rig_con[val - 2].insert_cell(max_width)
+
+            # Move to the left and update values as we have finished modifying
+            #   everything which affects its vacancy/partition values
+            for a in reversed(range(tableau_height, val - 2)):
+                max_width = self.ret_rig_con[a].insert_cell(max_width)
+                self._update_vacancy_nums(a + 1)
+                self._update_partition_values(a + 1)
+
+            # Update the final rigged tableau
+            # Note if tabelauHeight = n+1, then we must have val = n+1 (in order
+            #   to be column strict increasing), but then tableau_height is never
+            #   greater than val, so we don't enter into this statement.
+            self._update_vacancy_nums(tableau_height)
+            self._update_partition_values(tableau_height)
+
+            if val - 1 < n:
+                self._update_vacancy_nums(val - 1)
+
+            if tableau_height > 0:
+                self._update_vacancy_nums(tableau_height - 1)
+        elif tableau_height - 1 < n:
+            # Otherwise we just need to update the vacancy numbers that are affected
+            if tableau_height < n:
+                self._update_vacancy_nums(tableau_height)
+
+            if tableau_height > 0:
+                self._update_vacancy_nums(tableau_height - 1)
+
+
+class RCToKRTBijectionTypeA(RCToKRTBijectionAbstract):
+    r"""
+    Specific implementation of the bijection from rigged configurations to
+    tensor products of KR tableaux for type `A_n^{(1)}`.
+    """
+
+    def next_state(self, height):
+        r"""
+        Build the next state for type `A_n^{(1)}`.
+
+        EXAMPLES::
+
+            sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 1]])
+            sage: from sage.combinat.rigged_configurations.bij_type_A import RCToKRTBijectionTypeA
+            sage: bijection = RCToKRTBijectionTypeA(RC(partition_list=[[1],[1],[1],[1]]))
+            sage: bijection.next_state(1)
+            5
+        """
+        height -= 1  # indexing
+        n = self.n
+        ell = [None] * n
+        b = None
+
+        # Calculate the rank and ell values
+        last_size = 0
+        a = height
+        for partition in self.cur_partitions[height:]:
+            ell[a] = self._find_singular_string(partition, last_size)
+
+            if ell[a] is None:
+                b = a + 1
+                break
+            else:
+                last_size = partition[ell[a]]
+            a += 1
+
+        if b is None:
+            b = n + 1
+
+        # Determine the new rigged configuration by removing a box from the selected
+        #   string and then making the new string singular
+        row_num = self.cur_partitions[0].remove_cell(ell[0])
+        for a in range(1, n):
+            row_num_next = self.cur_partitions[a].remove_cell(ell[a])
+
+            self._update_vacancy_numbers(a - 1)
+            if row_num is not None:
+                self.cur_partitions[a - 1].rigging[row_num] = self.cur_partitions[a - 1].vacancy_numbers[row_num]
+            row_num = row_num_next
+
+        self._update_vacancy_numbers(n - 1)
+        if row_num is not None:
+            self.cur_partitions[n - 1].rigging[row_num] = self.cur_partitions[n - 1].vacancy_numbers[row_num]
+
+        return b