some pep8 cleanup in rigged-configurations

Author: fchapoton

src/sage/combinat/rigged_configurations/bij_abstract_class.py

@@ -17,7 +17,7 @@
 - Travis Scrimshaw (2011-04-15): Initial version
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2011, 2012 Travis Scrimshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -29,8 +29,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from copy import deepcopy
 from sage.misc.abstract_method import abstract_method
@@ -120,19 +120,19 @@ def run(self, verbose=False):
         """
         if verbose:
             from sage.combinat.rigged_configurations.tensor_product_kr_tableaux_element \
-              import TensorProductOfKirillovReshetikhinTableauxElement
+                import TensorProductOfKirillovReshetikhinTableauxElement
 
         for cur_crystal in reversed(self.tp_krt):
             target = cur_crystal.parent()._r
             # 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_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] = self._next_index(self.cur_dims[0][0], target)
-                    val = letter.value # Convert from a CrystalOfLetter to an Integer
+                    val = letter.value  # Convert from a CrystalOfLetter to an Integer
 
                     if verbose:
                         print("====================")
@@ -142,7 +142,7 @@ def run(self, verbose=False):
                         print("--------------------\n")
 
                     # Build the next state
-                    self.cur_path[0].insert(0, [letter]) # Prepend the value
+                    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
@@ -166,7 +166,7 @@ def run(self, verbose=False):
                     for a in range(self.n):
                         self._update_vacancy_nums(a)
 
-        self.ret_rig_con.set_immutable() # Return it to immutable
+        self.ret_rig_con.set_immutable()  # Return it to immutable
         return self.ret_rig_con
 
     @abstract_method
@@ -220,7 +220,7 @@ def _update_vacancy_nums(self, a):
         """
         # Check to make sure we have a valid index (currently removed)
         # If the current tableau is empty, there is nothing to do
-        if not self.ret_rig_con[a]: # Check to see if we have vacancy numbers
+        if not self.ret_rig_con[a]:  # Check to see if we have vacancy numbers
             return
 
         # Setup the first block
@@ -268,7 +268,7 @@ def _update_partition_values(self, a):
                     pos = 0
                     width = rigged_partition[index]
                     val = rigged_partition.rigging[index]
-                    for i in reversed(range(index-1)):
+                    for i in reversed(range(index - 1)):
                         if rigged_partition[i] > width or rigged_partition.rigging[i] >= val:
                             pos = i + 1
                             break
@@ -333,7 +333,7 @@ def __init__(self, RC_element):
         # This is a dummy edge to start the process
         cp = RC_element.__copy__()
         cp.set_immutable()
-        self._graph = [ [[], (cp, 0)] ]
+        self._graph = [[[], (cp, 0)]]
 
     def __eq__(self, rhs):
         r"""
@@ -414,7 +414,7 @@ def run(self, verbose=False, build_graph=False):
                         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'])
 
-                while self.cur_dims[0][0]: # > 0:
+                while self.cur_dims[0][0]:  # > 0:
                     if verbose:
                         print("====================")
                         print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))
@@ -427,16 +427,16 @@ def run(self, verbose=False, build_graph=False):
                     b = self.next_state(ht)
 
                     # Make sure we have a crystal letter
-                    ret_crystal_path[-1].append(letters(b)) # Append the rank
+                    ret_crystal_path[-1].append(letters(b))  # Append the rank
 
                     if build_graph:
                         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)), letters(b)])
 
-                self.cur_dims.pop(0) # Pop off the leading column
+                self.cur_dims.pop(0)  # Pop off the leading column
 
         if build_graph:
-            self._graph.pop(0) # Remove the dummy at the start
+            self._graph.pop(0)  # Remove the dummy at the start
             from sage.graphs.digraph import DiGraph
             from sage.graphs.dot2tex_utils import have_dot2tex
             self._graph = DiGraph(self._graph, format="list_of_edges")

src/sage/combinat/rigged_configurations/bij_infinity.py

@@ -175,13 +175,13 @@ def _call_(self, x):
         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]) ], [])
+            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])], [])
+            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) ], [])
+            l = sum([[[r, 1]]*lam[i] for i, r in enumerate(I)], [])
 
         RC = RiggedConfigurations(ct.affine(), reversed(l))
         elt = RC(x)

src/sage/combinat/rigged_configurations/bij_type_A.py

@@ -21,7 +21,7 @@
     sage: TestSuite(bijection).run()
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2011, 2012 Travis Scrimshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -33,8 +33,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  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
@@ -122,7 +122,7 @@ def next_state(self, height):
             sage: bijection.next_state(1)
             5
         """
-        height -= 1 # indexing
+        height -= 1  # indexing
         n = self.n
         ell = [None] * n
         b = None
@@ -158,4 +158,4 @@ def next_state(self, height):
         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)
+        return b

src/sage/combinat/rigged_configurations/bij_type_A2_dual.py

@@ -20,7 +20,7 @@
     sage: TestSuite(bijection).run()
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2012 Travis Scrimshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -32,8 +32,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.combinat.rigged_configurations.bij_type_C import KRTToRCBijectionTypeC
 from sage.combinat.rigged_configurations.bij_type_C import RCToKRTBijectionTypeC
@@ -155,7 +155,7 @@ def next_state(self, val):
                     else:
                         j = i - 1
                         while j >= 0 and partition._list[j] <= max_width + 2:
-                            partition.rigging[j+1] = partition.rigging[j] # Shuffle it along
+                            partition.rigging[j+1] = partition.rigging[j]  # Shuffle it along
                             j -= 1
                         partition._list.pop(i)
                         partition._list.insert(j+1, max_width + 2)
@@ -219,7 +219,7 @@ def next_state(self, height):
             sage: bijection.next_state(2)
             -1
         """
-        height -= 1 # indexing
+        height -= 1  # indexing
         n = self.n
         ell = [None] * (2*n)
         case_S = [False] * n
@@ -333,4 +333,4 @@ def next_state(self, height):
             else:
                 self.cur_partitions[n-1].rigging[row_num_bar_next] = self.cur_partitions[n-1].vacancy_numbers[row_num_bar_next]
 
-        return(b)
+        return b

src/sage/combinat/rigged_configurations/bij_type_A2_even.py

@@ -20,7 +20,7 @@
     sage: TestSuite(bijection).run()
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2012 Travis Scrimshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -32,8 +32,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.combinat.rigged_configurations.bij_type_A import KRTToRCBijectionTypeA
 from sage.combinat.rigged_configurations.bij_type_C import KRTToRCBijectionTypeC
@@ -139,7 +139,7 @@ def next_state(self, height):
             sage: bijection.next_state(2)
             -1
         """
-        height -= 1 # indexing
+        height -= 1  # indexing
         n = self.n
         ell = [None] * (2*n)
         case_S = [False] * n
@@ -213,4 +213,4 @@ def next_state(self, height):
         if row_num_bar is not None:
             self.cur_partitions[n-1].rigging[row_num_bar] = self.cur_partitions[n-1].vacancy_numbers[row_num_bar]
 
-        return(b)
+        return b

src/sage/combinat/rigged_configurations/bij_type_A2_odd.py

@@ -20,7 +20,7 @@
     sage: TestSuite(bijection).run()
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2012 Travis Scrimshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -32,8 +32,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.combinat.rigged_configurations.bij_type_A import KRTToRCBijectionTypeA
 from sage.combinat.rigged_configurations.bij_type_A import RCToKRTBijectionTypeA
@@ -126,7 +126,7 @@ def next_state(self, height):
             sage: bijection.next_state(1)
             -2
         """
-        height -= 1 # indexing
+        height -= 1  # indexing
         n = self.n
         ell = [None] * (2*n)
         b = None
@@ -194,4 +194,4 @@ def next_state(self, height):
         if ret_row_next is not None:
             self.cur_partitions[n-1].rigging[ret_row_next] = self.cur_partitions[n-1].vacancy_numbers[ret_row_next]
 
-        return(b)
+        return b