gh-35917: some pep8 fixes in combinat
    
<!-- Please provide a concise, informative and self-explanatory title.
-->
<!-- Don't put issue numbers in the title. Put it in the Description
below. -->
<!-- For example, instead of "Fixes #12345", use "Add a new method to
multiply two integers" -->

### 📚 Description

just fixing a few pycodestyle warnings in `combinat` folder

<!-- Describe your changes here in detail. -->
<!-- Why is this change required? What problem does it solve? -->
<!-- If this PR resolves an open issue, please link to it here. For
example "Fixes #12345". -->
<!-- If your change requires a documentation PR, please link it
appropriately. -->

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. It should be `[x]` not `[x
]`. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #35917
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Matthias Köppe

Author: Release Manager

src/sage/combinat/composition.py

@@ -1436,6 +1436,7 @@ def specht_module_dimension(self, base_ring=None):
         from sage.combinat.specht_module import specht_module_rank
         return specht_module_rank(self, base_ring)
 
+
 Sequence.register(Composition)
 ##############################################################
 

src/sage/combinat/diagram.py

@@ -152,7 +152,7 @@ def __init__(self, parent, cells, n_rows=None, n_cols=None, check=True):
             # minimum possible number of rows/cols
             N_rows = max(c[0] for c in self._cells)
             N_cols = max(c[1] for c in self._cells)
-        else: # if there are no cells
+        else:  # if there are no cells
             N_rows = -1
             N_cols = -1
 
@@ -344,18 +344,22 @@ def _latex_(self):
         def end_line(r):
             # give the line ending to row ``r``
             if r == 0:
-                return "".join(r'\cline{%s-%s}'%(i+1, i+1) for i,j in enumerate(array[0]) if j is not None)
+                return "".join(r'\cline{%s-%s}' % (i+1, i+1)
+                               for i, j in enumerate(array[0]) if j is not None)
             elif r == len(array):
-                return r"\\" + "".join(r'\cline{%s-%s}'%(i+1, i+1) for i,j in enumerate(array[r-1]) if j is not None)
+                return r"\\" + "".join(r'\cline{%s-%s}' % (i+1, i+1)
+                                       for i, j in enumerate(array[r-1]) if j is not None)
             else:
-                out = r"\\" + "".join(r'\cline{%s-%s}'%(i+1, i+1) for i,j in enumerate(array[r-1]) if j is not None)
-                out += "".join(r'\cline{%s-%s}'%(i+1, i+1) for i,j in enumerate(array[r]) if j is not None)
+                out = r"\\" + "".join(r'\cline{%s-%s}' % (i+1, i+1)
+                                      for i, j in enumerate(array[r-1]) if j is not None)
+                out += "".join(r'\cline{%s-%s}' % (i+1, i+1)
+                               for i, j in enumerate(array[r]) if j is not None)
                 return out
 
-        tex=r'\raisebox{-.6ex}{$\begin{array}[b]{*{%s}{p{0.6ex}}}'%(max(map(len,array)))
-        tex+=end_line(0)+'\n'
+        tex = r'\raisebox{-.6ex}{$\begin{array}[b]{*{%s}{p{0.6ex}}}' % (max(map(len, array)))
+        tex += end_line(0)+'\n'
         for r in range(len(array)):
-            tex+='&'.join('' if c is None else r'\lr{%s}'%(c,) for c in array[r])
+            tex += '&'.join('' if c is None else r'\lr{%s}' % (c,) for c in array[r])
             tex += end_line(r+1)+'\n'
         return '{%s\n%s\n}' % (lr, tex+r'\end{array}$}')
 
@@ -531,6 +535,7 @@ def specht_module_dimension(self, base_ring=None):
         from sage.combinat.specht_module import specht_module_rank
         return specht_module_rank(self, base_ring)
 
+
 class Diagrams(UniqueRepresentation, Parent):
     r"""
     The class of combinatorial diagrams.
@@ -624,7 +629,7 @@ def __iter__(self):
         while True:
             cells = next(X)
             try:
-                yield self.element_class(self, tuple((i, j) for i,j in cells))
+                yield self.element_class(self, tuple((i, j) for i, j in cells))
             except ValueError:
                 # if cells causes the .check method of a
                 # subclass to fail, just go to the next one
@@ -800,9 +805,9 @@ def from_zero_one_matrix(self, M, check=True):
             one = M.base_ring().one()
             for i in range(n_rows):
                 for j in range(n_cols):
-                    if not (M[i,j] == zero or M[i,j] == one):
-                        raise ValueError("Matrix entries must be 0 or 1")
-        cells = [(i, j) for i in range(n_rows) for j in range(n_cols) if M[i,j]]
+                    if not (M[i, j] == zero or M[i, j] == one):
+                        raise ValueError("matrix entries must be 0 or 1")
+        cells = [(i, j) for i in range(n_rows) for j in range(n_cols) if M[i, j]]
 
         return self.element_class(self, cells, n_rows, n_cols, check=False)
 

src/sage/combinat/fully_packed_loop.py

@@ -49,19 +49,19 @@
 D = (0, -1)
 
 FPL_edges = (
-#   0 UD   1 RD,  2 UR,  3 LR,  4 LD   5 LU
-   ((D,U), (L,D), (D,R), (R,L), (L,U), (R,U)),  # even
-   ((R,L), (R,U), (L,U), (D,U), (D,R), (L,D))   # odd
-   )
+    # 0 UD    1 RD,   2 UR,   3 LR,   4 LD    5 LU
+    ((D, U), (L, D), (D, R), (R, L), (L, U), (R, U)),  # even
+    ((R, L), (R, U), (L, U), (D, U), (D, R), (L, D))   # odd
+)
 
 FPL_turns = (
-# 0 UD          1 RD          2 UR          3 LR          4 LD          5 LU
- ({U: U, D: D}, {R: D, U: L}, {U: R, L: D}, {L: L, R: R}, {R: U, D: L}, {L: U, D: R}), # even
- ({L: L, R: R}, {L: U, D: R}, {R: U, D: L}, {U: U, D: D}, {U: R, L: D}, {R: D, U: L})  # odd
- )
+    # 0 UD          1 RD          2 UR          3 LR          4 LD          5 LU
+    ({U: U, D: D}, {R: D, U: L}, {U: R, L: D}, {L: L, R: R}, {R: U, D: L}, {L: U, D: R}),  # even
+    ({L: L, R: R}, {L: U, D: R}, {R: U, D: L}, {U: U, D: D}, {U: R, L: D}, {R: D, U: L})   # odd
+)
 
 
-def _make_color_list(n, colors=None,  color_map=None, randomize=False):
+def _make_color_list(n, colors=None, color_map=None, randomize=False):
     r"""
     TESTS::
 
@@ -530,7 +530,7 @@ def __classcall_private__(cls, generator):
             M = generator.to_alternating_sign_matrix().to_matrix()
             AlternatingSignMatrix(M)
             SVM = generator
-        else: # Not ASM nor SVM
+        else:  # Not ASM nor SVM
             try:
                 SVM = AlternatingSignMatrix(generator).to_six_vertex_model()
             except (TypeError, ValueError):
@@ -608,22 +608,22 @@ def _repr_(self):
         # List are in the order of URDL
         # One set of rules for how to draw around even vertex, one set of rules for odd vertex
         n = len(self._six_vertex_model) - 1
-        ascii1 = [[r'     ', ' -', r'     ', '- '], # LR
-                 [r'  |  ', '  ', r'     ', '- '], # LU
-                 [r'     ', '  ', r'  |  ', '- '], # LD
-                 [r'  |  ', '  ', r'  |  ', '  '], # UD
-                 [r'  |  ', ' -', r'     ', '  '], # UR
-                 [r'     ', ' -', r'  |  ', '  ']] # RD
-
-        ascii2 = [[r'  |  ', '  ', r'  |  ', '  '], # LR
-                 [r'     ', ' -', r'  |  ', '  '], # LU
-                 [r'  |  ', ' -', r'     ', '  '], # LD
-                 [r'     ', ' -', r'     ', '- '], # UD
-                 [r'     ', '  ', r'  |  ', '- '], # UR
-                 [r'  |  ', '  ', r'     ', '- ']] # RD
+        ascii1 = [[r'     ', ' -', r'     ', '- '],  # LR
+                 [r'  |  ', '  ', r'     ', '- '],  # LU
+                 [r'     ', '  ', r'  |  ', '- '],  # LD
+                 [r'  |  ', '  ', r'  |  ', '  '],  # UD
+                 [r'  |  ', ' -', r'     ', '  '],  # UR
+                 [r'     ', ' -', r'  |  ', '  ']]  # RD
+
+        ascii2 = [[r'  |  ', '  ', r'  |  ', '  '],  # LR
+                 [r'     ', ' -', r'  |  ', '  '],  # LU
+                 [r'  |  ', ' -', r'     ', '  '],  # LD
+                 [r'     ', ' -', r'     ', '- '],  # UD
+                 [r'     ', '  ', r'  |  ', '- '],  # UR
+                 [r'  |  ', '  ', r'     ', '- ']]  # RD
         ret = '  '
         # Do the top line
-        for i,entry in enumerate(self._six_vertex_model[0]):
+        for i, entry in enumerate(self._six_vertex_model[0]):
             if i % 2 == 0:
                 ret += '  |  '
             else:
@@ -632,47 +632,47 @@ def _repr_(self):
         plus_sign = '+'
 
         # Do the meat of the ascii art
-        for j,row in enumerate(self._six_vertex_model):
+        for j, row in enumerate(self._six_vertex_model):
             ret += '\n  '
             # Do the top row
-            for i,entry in enumerate(row):
+            for i, entry in enumerate(row):
                 if (i + j) % 2 == 0:
                     ret += ascii1[entry][0]
                 else:
                     ret += ascii2[entry][0]
             ret += '\n'
 
             # Do the left-most entry
-            if (j) % 2 == 0:
+            if j % 2 == 0:
                 ret += '  '
             else:
                 ret += ' -'
 
             # Do the middle row
-            for i,entry in enumerate(row):
+            for i, entry in enumerate(row):
                 if (i + j) % 2 == 0:
                     ret += ascii1[entry][3] + plus_sign + ascii1[entry][1]
                 else:
                     ret += ascii2[entry][3] + plus_sign + ascii2[entry][1]
 
             # Do the right-most entry
-            if (j+n) % 2 ==0:
+            if (j+n) % 2 == 0:
                 ret += '  '
             else:
                 ret += '- '
 
             # Do the bottom row
             ret += '\n  '
-            for i,entry in enumerate(row):
-                if (i + j) % 2 ==0:
+            for i, entry in enumerate(row):
+                if (i + j) % 2 == 0:
                     ret += ascii1[entry][2]
                 else:
                     ret += ascii2[entry][2]
 
         # Do the bottom line
         ret += '\n  '
-        for i,entry in enumerate(self._six_vertex_model[-1]):
-            if (i+n+1) % 2 ==0:
+        for i, entry in enumerate(self._six_vertex_model[-1]):
+            if (i+n+1) % 2 == 0:
                 ret += '     '
             else:
                 ret += '  |  '
@@ -879,7 +879,7 @@ def plot(self, **options):
         unrank = self.parent()._boundary
         seen = [False] * (2*n)
 
-        squares = set((i,j) for i in range(n) for j in range(n))
+        squares = set((i, j) for i in range(n) for j in range(n))
 
         colors = _make_color_list(2*n,
                 colors=link_options.pop('colors', None),
@@ -922,7 +922,7 @@ def plot(self, **options):
                     loop_options['color'] = colors.pop()
 
                 # make it upside down
-                orbit = [(j, n - i - 1) for i,j in orbit]
+                orbit = [(j, n - i - 1) for i, j in orbit]
 
                 if fill:
                     G += polygon2d(orbit, **loop_options)
@@ -1025,13 +1025,13 @@ def _link_or_loop_from(self, pos, d0=None):
                 raise RuntimeError
 
         if i == -1 or j == -1 or i == n or j == n:
-            i0,j0 = orbit[0]
+            i0, j0 = orbit[0]
             if d0 is None and i0 != -1 and i0 != n and j0 != -1 and j0 != n:
                 # only half of a link -> compute the other half
-                i1,j1 = orbit[1]
+                i1, j1 = orbit[1]
                 d = (i0-i1, j0-j1)
                 orbit2 = self._link_or_loop_from(orbit[1], d)
-                assert orbit2[0] == (i1,j1) and orbit2[1] == (i0,j0)
+                assert orbit2[0] == (i1, j1) and orbit2[1] == (i0, j0)
                 return orbit2[:1:-1] + orbit
             return orbit
         else:
@@ -1156,7 +1156,7 @@ def link_pattern(self):
             if seen[k]:
                 continue
 
-            i,j = unrank(k)
+            i, j = unrank(k)
 
             # initial direction
             if i == -1:
@@ -1180,7 +1180,7 @@ def link_pattern(self):
                 d = FPL_turns[parity][conf][d]
 
             # update seen and link_pattern
-            l = rank((i,j))
+            l = rank((i, j))
             seen[k] = seen[l] = True
             link_pattern.append((k+1, l+1))
 
@@ -1294,7 +1294,7 @@ def _repr_(self):
             sage: FPLs = FullyPackedLoops(4); FPLs
             Fully packed loops on a 4x4 grid
         """
-        return "Fully packed loops on a %sx%s grid" % (self._n,self._n)
+        return "Fully packed loops on a %sx%s grid" % (self._n, self._n)
 
     def __contains__(self, fpl):
         """
@@ -1368,7 +1368,7 @@ def _element_constructor_(self, generator):
         if isinstance(generator, AlternatingSignMatrix):
             SVM = generator.to_six_vertex_model()
         elif isinstance(generator, SquareIceModel.Element) or \
-        isinstance(generator, SixVertexConfiguration):
+                isinstance(generator, SixVertexConfiguration):
             SVM = generator
         else:  # Not ASM nor SVM
             try:
@@ -1407,11 +1407,11 @@ def cardinality(self):
 
         EXAMPLES::
 
-            sage: [AlternatingSignMatrices(n).cardinality() for n in range(11)]
-            [1, 1, 2, 7, 42, 429, 7436, 218348, 10850216, 911835460, 129534272700]
+            sage: [AlternatingSignMatrices(n).cardinality() for n in range(10)]
+            [1, 1, 2, 7, 42, 429, 7436, 218348, 10850216, 911835460]
         """
-        return Integer(prod( [ factorial(3*k+1)/factorial(self._n+k)
-                       for k in range(self._n)] ))
+        return Integer(prod(factorial(3 * k + 1) / factorial(self._n + k)
+                            for k in range(self._n)))
 
     def _an_element_(self):
         """
@@ -1433,9 +1433,9 @@ def _an_element_(self):
                 |         |
                 |         |
         """
-        #ASM = AlternatingSignMatrix(matrix.identity(self._n))
-        #SVM = ASM.to_six_vertex_model()
-        SVM = SixVertexModel(self._n,boundary_conditions='ice').an_element()
+        # ASM = AlternatingSignMatrix(matrix.identity(self._n))
+        # SVM = ASM.to_six_vertex_model()
+        SVM = SixVertexModel(self._n, boundary_conditions='ice').an_element()
         return self.element_class(self, SVM)
 
     def _boundary(self, k):
@@ -1457,19 +1457,19 @@ def _boundary(self, k):
             True
         """
         n = self._n
-        n_LR = n//2 if n%2 == 0 else (n+1) // 2
-        n_TB = n//2 if n%2 == 0 else (n-1) // 2
+        n_LR = n//2 if n % 2 == 0 else (n+1) // 2
+        n_TB = n//2 if n % 2 == 0 else (n-1) // 2
         if k < n_LR:
             return (-1, 2*k)
         k -= n_LR
         if k < n_TB:
-            return (n%2 + 2*k, n)
+            return (n % 2 + 2*k, n)
         k -= n_TB
         if k < n_LR:
             return (n, n - 1 - 2*k)
         k -= n_LR
         if k < n_TB:
-            return (n - 1 - n%2 - 2*k, -1)
+            return (n - 1 - n % 2 - 2*k, -1)
 
     def _boundary_index(self, pos):
         r"""

src/sage/combinat/growth.py

@@ -797,8 +797,8 @@ def rotate(self):
         """
         l = self._lambda[0]
         h = len(self._lambda)
-        shape_lambda = [l-p for p in self._mu] + [l]*(h-len(self._mu))
-        shape_mu     = [l-p for p in self._lambda]
+        shape_lambda = [l - p for p in self._mu] + [l] * (h - len(self._mu))
+        shape_mu = [l - p for p in self._lambda]
         shape = SkewPartition([shape_lambda[::-1], shape_mu[::-1]])
         F = {(l-i-1, h-j-1): v for (i,j),v in self._filling.items()}
         return GrowthDiagram(self.rule,

src/sage/combinat/key_polynomial.py

@@ -794,6 +794,7 @@ def divided_difference(f, i):
     si_f = f.subs({z[i]: z[i-1], z[i-1]: z[i]})
     return (si_f - f) // (z[i] - z[i-1])
 
+
 def isobaric_divided_difference(f, w):
     r"""
     Apply the isobaric divided difference operator `\pi_w` to the
@@ -839,6 +840,7 @@ def isobaric_divided_difference(f, w):
         f = (si_fp - fp) // (z[i] - z[i-1])
     return f
 
+
 def sorting_word(alpha):
     r"""
     Get a reduced word for the permutation which sorts ``alpha``