gh-35909: some pep8 fixes in topology/
    
<!-- 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

This fixes many small pycodestyle warnings in the `topology` folder,
except mainly E226

<!-- 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: #35909
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Matthias Köppe

Author: Release Manager

src/sage/topology/cell_complex.py

@@ -79,7 +79,7 @@ class :class:`~sage.homology.delta_complex.DeltaComplex`
         sage: from sage.topology.cell_complex import GenericCellComplex
         sage: A = GenericCellComplex()
     """
-    def __eq__(self,right):
+    def __eq__(self, right):
         """
         Comparisons of cell complexes are not implemented.
 
@@ -94,7 +94,7 @@ def __eq__(self,right):
         """
         raise NotImplementedError
 
-    def __ne__(self,right):
+    def __ne__(self, right):
         """
         Comparisons of cell complexes are not implemented.
 
@@ -254,7 +254,7 @@ def f_vector(self):
             sage: cubical_complexes.KleinBottle().f_vector()
             [1, 42, 84, 42]
         """
-        return [self._f_dict()[n] for n in range(-1, self.dimension()+1)]
+        return [self._f_dict()[n] for n in range(-1, self.dimension() + 1)]
 
     def _f_dict(self):
         """
@@ -290,7 +290,7 @@ def euler_characteristic(self):
             sage: cubical_complexes.KleinBottle().euler_characteristic()
             0
         """
-        return sum([(-1)**n * self.f_vector()[n+1] for n in range(self.dimension() + 1)])
+        return sum((-1)**n * self.f_vector()[n + 1] for n in range(self.dimension() + 1))
 
     ############################################################
     # end of methods using self.cells()
@@ -543,9 +543,6 @@ def homology(self, dim=None, base_ring=ZZ, subcomplex=None,
             sage: S.homology(generators=True)                                           # optional - sage.modules
             {0: [], 1: 0, 2: [(Z, sigma_2)]}
         """
-        from sage.topology.cubical_complex import CubicalComplex
-        from sage.topology.simplicial_complex import SimplicialComplex
-        from sage.modules.free_module import VectorSpace
         from sage.homology.homology_group import HomologyGroup
 
         if dim is not None:
@@ -599,8 +596,8 @@ def homology(self, dim=None, base_ring=ZZ, subcomplex=None,
         return answer.get(dim, zero)
 
     def cohomology(self, dim=None, base_ring=ZZ, subcomplex=None,
-                 generators=False, algorithm='pari',
-                 verbose=False, reduced=True):
+                   generators=False, algorithm='pari',
+                   verbose=False, reduced=True):
         r"""
         The reduced cohomology of this cell complex.
 

src/sage/topology/cubical_complex.py

@@ -226,7 +226,7 @@ def _translate(self, vec):
         """
         t = self.__tuple
         embed = max(len(t), len(vec))
-        t = t + ((0,0),) * (embed-len(t))
+        t = t + ((0, 0),) * (embed-len(t))
         vec = tuple(vec) + (0,) * (embed-len(vec))
         new = []
         for (a, b) in zip(t, vec):
@@ -367,7 +367,7 @@ def face(self, n, upper=True):
             new = t[idx][1]
         else:
             new = t[idx][0]
-        return Cube(t[0:idx] + ((new,new),) + t[idx+1:])
+        return Cube(t[0:idx] + ((new, new),) + t[idx+1:])
 
     def faces(self):
         """
@@ -380,8 +380,8 @@ def faces(self):
             sage: C.faces()
             [[2,2] x [3,4], [1,2] x [4,4], [1,1] x [3,4], [1,2] x [3,3]]
         """
-        upper = [self.face(i,True) for i in range(self.dimension())]
-        lower = [self.face(i,False) for i in range(self.dimension())]
+        upper = [self.face(i, True) for i in range(self.dimension())]
+        lower = [self.face(i, False) for i in range(self.dimension())]
         return upper + lower
 
     def faces_as_pairs(self):
@@ -464,7 +464,7 @@ def _compare_for_gluing(self, other):
         self_tuple = self.tuple()
         other_tuple = other.tuple()
         nondegen = (list(zip(self.nondegenerate_intervals(),
-                        other.nondegenerate_intervals()))
+                             other.nondegenerate_intervals()))
                     + [(len(self_tuple), len(other_tuple))])
         old = (-1, -1)
         self_added = 0
@@ -540,10 +540,10 @@ def _triangulation_(self):
             6
         """
         from .simplicial_complex import Simplex
-        if self.dimension() < 0: # the empty cube
-            return [Simplex(())] # the empty simplex
+        if self.dimension() < 0:  # the empty cube
+            return [Simplex(())]  # the empty simplex
         v = tuple([max(j) for j in self.tuple()])
-        if self.dimension() == 0: # just v
+        if self.dimension() == 0:  # just v
             return [Simplex((v,))]
         simplices = []
         for i in range(self.dimension()):
@@ -594,7 +594,7 @@ def alexander_whitney(self, dim):
             nu = 0
             for i in J:
                 for j in Jprime:
-                    if j<i:
+                    if j < i:
                         nu += 1
             t = self.tuple()
             left = []
@@ -717,7 +717,7 @@ def _repr_(self):
             sage: C1._repr_()
             '[1,1] x [2,3] x [4,5]'
         """
-        s = ["[%s,%s]"%(str(x), str(y)) for (x,y) in self.__tuple]
+        s = ("[%s,%s]" % (str(x), str(y)) for x, y in self.__tuple)
         return " x ".join(s)
 
     def _latex_(self):
@@ -1074,7 +1074,7 @@ def cells(self, subcomplex=None):
             sub_facets = {}
             dimension = max([cube.dimension() for cube in self._facets])
             # initialize the lists: add each maximal cube to Cells and sub_facets
-            for i in range(-1,dimension+1):
+            for i in range(-1, dimension+1):
                 Cells[i] = set([])
                 sub_facets[i] = set([])
             for f in self._facets:
@@ -1214,7 +1214,7 @@ def chain_complex(self, subcomplex=None, augmented=False,
             differentials[0] = mat
         current = vertices
         # now loop from 1 to dimension of the complex
-        for dim in range(1,self.dimension()+1):
+        for dim in range(1, self.dimension()+1):
             if verbose:
                 print("  starting dimension %s" % dim)
             if (dim, subcomplex) in self._complex:
@@ -1488,9 +1488,9 @@ def disjoint_union(self, other):
         zero = [0] * max(embedded_left, embedded_right)
         facets = []
         for f in self.maximal_cells():
-            facets.append(Cube([[0,0]]).product(f._translate(zero)))
+            facets.append(Cube([[0, 0]]).product(f._translate(zero)))
         for f in other.maximal_cells():
-            facets.append(Cube([[1,1]]).product(f._translate(zero)))
+            facets.append(Cube([[1, 1]]).product(f._translate(zero)))
         return CubicalComplex(facets)
 
     def wedge(self, other):
@@ -1522,7 +1522,7 @@ def wedge(self, other):
         embedded_right = len(tuple(other.maximal_cells()[0]))
         translate_left = [-a[0] for a in self.maximal_cells()[0]] + [0] * embedded_right
         translate_right = [-a[0] for a in other.maximal_cells()[0]]
-        point_right = Cube([[0,0]] * embedded_left)
+        point_right = Cube([[0, 0]] * embedded_left)
 
         facets = []
         for f in self.maximal_cells():
@@ -1584,7 +1584,7 @@ def connected_sum(self, other):
         # start assembling the facets in the connected sum: first, the
         # cylinder on the removed face.
         new_facets = []
-        cylinder = removed.product(Cube([[0,1]]))
+        cylinder = removed.product(Cube([[0, 1]]))
         # don't want to include the ends of the cylinder, so don't
         # include the last pair of faces.  therefore, choose faces up
         # to removed.dimension(), not cylinder.dimension().
@@ -1596,13 +1596,13 @@ def connected_sum(self, other):
             CL = list(cube.tuple())
             for (idx, L) in insert_self:
                 CL[idx:idx] = L
-            CL.append((0,0))
+            CL.append((0, 0))
             new_facets.append(Cube(CL))
         for cube in other_facets:
             CL = list(cube.tuple())
             for (idx, L) in insert_other:
                 CL[idx:idx] = L
-            CL.append((1,1))
+            CL.append((1, 1))
             new_facets.append(Cube(CL)._translate(translate))
         return CubicalComplex(new_facets)
 
@@ -1813,7 +1813,7 @@ class CubicalComplexExamples():
         Cubical complex with 256 vertices and 6560 cubes
     """
 
-    def Sphere(self,n):
+    def Sphere(self, n):
         r"""
         A cubical complex representation of the `n`-dimensional sphere,
         formed by taking the boundary of an `(n+1)`-dimensional cube.
@@ -1826,7 +1826,7 @@ def Sphere(self,n):
             sage: cubical_complexes.Sphere(7)
             Cubical complex with 256 vertices and 6560 cubes
         """
-        return CubicalComplex(Cube([[0,1]]*(n+1)).faces())
+        return CubicalComplex(Cube([[0, 1]]*(n+1)).faces())
 
     def Torus(self):
         r"""

src/sage/topology/delta_complex.py

@@ -640,14 +640,14 @@ def chain_complex(self, subcomplex=None, augmented=False,
             empty_simplex = 0
         vertices = self.n_cells(0, subcomplex=subcomplex)
         old = vertices
-        old_real = [x for x in old if x is not None] # get rid of faces not in subcomplex
+        old_real = [x for x in old if x is not None]  # remove faces not in subcomplex
         n = len(old_real)
         differentials[0] = matrix(base_ring, empty_simplex, n, n*empty_simplex*[1])
         # current is list of simplices in dimension dim
         # current_real is list of simplices in dimension dim, with None filtered out
         # old is list of simplices in dimension dim-1
         # old_real is list of simplices in dimension dim-1, with None filtered out
-        for dim in range(1,self.dimension()+1):
+        for dim in range(1, self.dimension()+1):
             current = list(self.n_cells(dim, subcomplex=subcomplex))
             current_real = [x for x in current if x is not None]
             i = 0
@@ -665,10 +665,10 @@ def chain_complex(self, subcomplex=None, augmented=False,
                 for row in s:
                     if old[row] is not None:
                         actual_row = translate[row]
-                        if (actual_row,col) in mat_dict:
-                            mat_dict[(actual_row,col)] += sign
+                        if (actual_row, col) in mat_dict:
+                            mat_dict[(actual_row, col)] += sign
                         else:
-                            mat_dict[(actual_row,col)] = sign
+                            mat_dict[(actual_row, col)] = sign
                     sign *= -1
                 col += 1
             differentials[dim] = matrix(base_ring, len(old_real), len(current_real), mat_dict)
@@ -827,17 +827,17 @@ def join(self, other):
         data.append(self.n_cells(0) + other.n_cells(0))
         bdries = {}
         for l_idx in range(len(self.n_cells(0))):
-            bdries[(0,l_idx,-1,0)] = l_idx
+            bdries[(0, l_idx, -1, 0)] = l_idx
         for r_idx in range(len(other.n_cells(0))):
-            bdries[(-1,0,0,r_idx)] = len(self.n_cells(0)) + r_idx
+            bdries[(-1, 0, 0, r_idx)] = len(self.n_cells(0)) + r_idx
         # dimension of the join:
         maxdim = self.dimension() + other.dimension() + 1
         # now for the d-cells, d>0:
-        for d in range(1,maxdim+1):
+        for d in range(1, maxdim+1):
             d_cells = []
             positions = {}
             new_idx = 0
-            for k in range(-1,d+1):
+            for k in range(-1, d+1):
                 n = d-1-k
                 # d=n+k.  need a k-cell from self and an n-cell from other
                 if k == -1:
@@ -919,11 +919,11 @@ def suspension(self, n=1):
             sage: S3.homology()
             {0: 0, 1: 0, 2: 0, 3: Z}
         """
-        if n<0:
+        if n < 0:
             raise ValueError("n must be non-negative")
-        if n==0:
+        if n == 0:
             return self
-        if n==1:
+        if n == 1:
             return self.join(delta_complexes.Sphere(0))
         return self.suspension().suspension(int(n-1))
 
@@ -975,8 +975,8 @@ def product(self, other):
             for w in other.n_cells(0):
                 # one vertex for each pair (v,w)
                 # store its indices in bdries; store its boundary in vertices
-                bdries[(0,l_idx,0,r_idx, ((0,0),))] = len(vertices)
-                vertices.append(()) # add new vertex (simplex with empty bdry)
+                bdries[(0, l_idx, 0, r_idx, ((0, 0),))] = len(vertices)
+                vertices.append(())  # add new vertex (simplex with empty bdry)
                 r_idx += 1
             l_idx += 1
         data.append(tuple(vertices))
@@ -988,7 +988,7 @@ def product(self, other):
         new = {}
         for d in range(1, maxdim+1):
             for k in range(d+1):
-                for n in range(d-k,d+1):
+                for n in range(d-k, d+1):
                     k_idx = 0
                     for k_cell in self.n_cells(k):
                         n_idx = 0
@@ -1011,8 +1011,8 @@ def product(self, other):
                                 bdry_list = []
                                 for i in range(d+1):
                                     face_path = path[:i] + path[i+1:]
-                                    if ((i<d and path[i][0] == path[i+1][0]) or
-                                        (i>0 and path[i][0] == path[i-1][0])):
+                                    if ((i < d and path[i][0] == path[i+1][0]) or
+                                            (i > 0 and path[i][0] == path[i-1][0])):
                                         # this k-simplex
                                         k_face_idx = k_idx
                                         k_face_dim = k
@@ -1021,12 +1021,12 @@ def product(self, other):
                                         k_face_idx = k_cell[path[i][0]]
                                         k_face_dim = k-1
                                         tail = []
-                                        for j in range(i,d):
+                                        for j in range(i, d):
                                             tail.append((face_path[j][0]-1,
-                                                       face_path[j][1]))
+                                                         face_path[j][1]))
                                         face_path = face_path[:i] + tuple(tail)
-                                    if ((i<d and path[i][1] == path[i+1][1]) or
-                                        (i>0 and path[i][1] == path[i-1][1])):
+                                    if ((i < d and path[i][1] == path[i+1][1]) or
+                                            (i > 0 and path[i][1] == path[i-1][1])):
                                         # this n-simplex
                                         n_face_idx = n_idx
                                         n_face_dim = n
@@ -1035,7 +1035,7 @@ def product(self, other):
                                         n_face_idx = n_cell[path[i][1]]
                                         n_face_dim = n-1
                                         tail = []
-                                        for j in range(i,d):
+                                        for j in range(i, d):
                                             tail.append((face_path[j][0],
                                                          face_path[j][1]-1))
                                         face_path = face_path[:i] + tuple(tail)
@@ -1383,7 +1383,7 @@ def _epi_from_standard_simplex(self, idx=-1, dim=None):
             faces_dict = {}
             for cell in n_cells:
                 if n > 1:
-                    faces = [tuple(simplex_cells[n-1][cell[j]]) for j in range(0,n+1)]
+                    faces = [tuple(simplex_cells[n-1][cell[j]]) for j in range(n+1)]
                     one_cell = dict(zip(faces, self_cells[n][n_cells[cell]]))
                 else:
                     temp = dict(zip(cell, self_cells[n][n_cells[cell]]))
@@ -1638,7 +1638,7 @@ class DeltaComplexExamples():
         False
     """
 
-    def Sphere(self,n):
+    def Sphere(self, n):
         r"""
         A `\Delta`-complex representation of the `n`-dimensional sphere,
         formed by gluing two `n`-simplices along their boundary,
@@ -1653,9 +1653,8 @@ def Sphere(self,n):
             Vector space of dimension 1 over Finite Field of size 3
         """
         if n == 1:
-            return DeltaComplex([ [()], [(0, 0)] ])
-        else:
-            return DeltaComplex({Simplex(n): True, Simplex(range(1,n+2)): Simplex(n)})
+            return DeltaComplex([[()], [(0, 0)]])
+        return DeltaComplex({Simplex(n): True, Simplex(range(1, n+2)): Simplex(n)})
 
     def Torus(self):
         r"""