passagemath-graphs 10.5.10__cp39-cp39-macosx_14_0_arm64.whl → 10.5.43__cp39-cp39-macosx_14_0_arm64.whl

sage/knots/link.py

@@ -516,9 +516,9 @@ class Link(SageObject):
             F = FreeGroup(len(arcs))
             rels = []
             for crossing, orientation in zip(self.pd_code(), self.orientation()):
-                a = arcs.index([i for i in arcs if crossing[0] in i][0])
-                b = arcs.index([i for i in arcs if crossing[3] in i][0])
-                c = arcs.index([i for i in arcs if crossing[2] in i][0])
+                a = next(idx for idx, i in enumerate(arcs) if crossing[0] in i)
+                b = next(idx for idx, i in enumerate(arcs) if crossing[3] in i)
+                c = next(idx for idx, i in enumerate(arcs) if crossing[2] in i)
                 ela = F.gen(a)
                 elb = F.gen(b)
                 if orientation < 0:
@@ -527,7 +527,7 @@ class Link(SageObject):
                 rels.append(ela * elb / elc / elb)
             return F.quotient(rels)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation.
 
@@ -706,9 +706,8 @@ class Link(SageObject):
             """
             i = cross.index(edge)
             if cross.count(edge) > 1:
-                return cross.index(edge, i+1)
-            else:
-                return i
+                return cross.index(edge, i + 1)
+            return i
 
         seifert_circles = self.seifert_circles()
         newedge = max(flatten(pd_code)) + 1
@@ -741,8 +740,8 @@ class Link(SageObject):
                             C1[idx(C1, a)] = newedge + 1
                             C2 = newPD[newPD.index(tails[b])]
                             C2[idx(C2, b)] = newedge + 2
-                            newPD.append([newedge + 3, newedge, b, a]) # D
-                            newPD.append([newedge + 2, newedge, newedge + 3, newedge + 1]) # E
+                            newPD.append([newedge + 3, newedge, b, a])  # D
+                            newPD.append([newedge + 2, newedge, newedge + 3, newedge + 1])  # E
                             self._braid = Link(newPD).braid(remove_loops=remove_loops)
                             return self._braid
                         else:
@@ -762,21 +761,21 @@ class Link(SageObject):
                             C1[idx(C1, -a)] = newedge + 1
                             C2 = newPD[newPD.index(tails[-b])]
                             C2[idx(C2, -b)] = newedge + 2
-                            newPD.append([newedge + 2, newedge + 1, newedge + 3, newedge]) # D
-                            newPD.append([newedge + 3, -a, -b, newedge]) # E
+                            newPD.append([newedge + 2, newedge + 1, newedge + 3, newedge])  # D
+                            newPD.append([newedge + 3, -a, -b, newedge])  # E
                             self._braid = Link(newPD).braid(remove_loops=remove_loops)
                             return self._braid
 
         # We are in the case where no Vogel moves are necessary.
         G = DiGraph()
         G.add_vertices([tuple(c) for c in seifert_circles])
-        for i,c in enumerate(pd_code):
+        for i, c in enumerate(pd_code):
             if self.orientation()[i] == 1:
-                a = [x for x in seifert_circles if c[3] in x][0]
-                b = [x for x in seifert_circles if c[0] in x][0]
+                a = next(x for x in seifert_circles if c[3] in x)
+                b = next(x for x in seifert_circles if c[0] in x)
             else:
-                a = [x for x in seifert_circles if c[0] in x][0]
-                b = [x for x in seifert_circles if c[1] in x][0]
+                a = next(x for x in seifert_circles if c[0] in x)
+                b = next(x for x in seifert_circles if c[1] in x)
             G.add_edge(tuple(a), tuple(b))
 
         # Get a simple path from a source to a sink in the digraph
@@ -786,7 +785,7 @@ class Link(SageObject):
         B = BraidGroup(len(ordered_cycles))
         available_crossings = copy(pd_code)
         oc_set = set(ordered_cycles[0])
-        for i,x in enumerate(pd_code):
+        for i, x in enumerate(pd_code):
             if any(elt in oc_set for elt in x):
                 crossing = x
                 crossing_index = i
@@ -904,7 +903,7 @@ class Link(SageObject):
                     heads[a] = next_crossing[0]
                     tails[a] = D
                     D = next_crossing[0]
-                    a = D[(D.index(a)+2) % 4]
+                    a = D[(D.index(a) + 2) % 4]
 
         unassigned = set(flatten(pd_code)).difference(set(tails))
         while unassigned:
@@ -921,7 +920,7 @@ class Link(SageObject):
                         break
                 heads[a] = next_crossing
                 D = next_crossing
-                a = D[(D.index(a)+2) % 4]
+                a = D[(D.index(a) + 2) % 4]
                 if a in unassigned:
                     unassigned.remove(a)
         return tails, heads
@@ -1111,7 +1110,7 @@ class Link(SageObject):
         nmax = max(flatten(crossings)) + 1
         for i in range(2 ** ncross):
             v = Integer(i).bits()
-            v = v + (ncross - len(v))*[0]
+            v = v + (ncross - len(v)) * [0]
             G = Graph()
             for j, cr in enumerate(crossings):
                 n = nmax + j
@@ -1135,7 +1134,7 @@ class Link(SageObject):
             smoothings.append((tuple(v), sm, iindex, jmin, jmax))
         states = []  # we got all the smoothings, now find all the states
         for sm in smoothings:
-            for k in range(len(sm[1])+1):
+            for k in range(len(sm[1]) + 1):
                 for circpos in combinations(sorted(sm[1]), k):  # Add each state
                     circneg = sm[1].difference(circpos)
                     j = writhe + sm[2] + len(circpos) - len(circneg)
@@ -1182,28 +1181,29 @@ class Link(SageObject):
         for st in states:
             i, j = st[3], st[4]
             if j == height:
-                if (i,j) in bases:
-                    bases[i,j].append(st)
+                if (i, j) in bases:
+                    bases[i, j].append(st)
                 else:
-                    bases[i,j] = [st]
+                    bases[i, j] = [st]
         complexes = {}
-        for (i, j) in bases:
-            if (i+1, j) in bases:
-                m = matrix(ring, len(bases[(i,j)]), len(bases[(i+1,j)]))
+        for (i, j), bij in bases.items():
+            if (i + 1, j) in bases:
+                m = matrix(ring, len(bij), len(bases[(i + 1, j)]))
                 for ii in range(m.nrows()):
-                    V1 = bases[(i,j)][ii]
+                    V1 = bij[ii]
                     for jj in range(m.ncols()):
-                        V2 = bases[(i+1, j)][jj]
+                        V2 = bases[(i + 1, j)][jj]
                         V20 = V2[0]
-                        difs = [index for index,value in enumerate(V1[0]) if value != V20[index]]
+                        difs = [index for index, value in enumerate(V1[0])
+                                if value != V20[index]]
                         if len(difs) == 1 and not (V2[2].intersection(V1[1]) or V2[1].intersection(V1[2])):
-                            m[ii,jj] = (-1)**sum(V2[0][x] for x in range(difs[0]+1, ncross))
+                            m[ii, jj] = (-1)**sum(V2[0][x] for x in range(difs[0] + 1, ncross))
                             # Here we have the matrix constructed, now we have to put it in the dictionary of complexes
             else:
-                m = matrix(ring, len(bases[(i,j)]), 0)
+                m = matrix(ring, len(bij), 0)
             complexes[i] = m.transpose()
-            if (i-1, j) not in bases:
-                complexes[i-1] = matrix(ring, len(bases[(i,j)]), 0)
+            if (i - 1, j) not in bases:
+                complexes[i - 1] = matrix(ring, len(bases[(i, j)]), 0)
         homologies = ChainComplex(complexes).homology()
         return tuple(sorted(homologies.items()))
 
@@ -1457,7 +1457,7 @@ class Link(SageObject):
                 for i, j in zip(last_component, first_component):
                     d_dic[i][1] = d_dic[j][0]
                 crossing_dic = {}
-                for i,x in enumerate(oriented_gauss_code[1]):
+                for i, x in enumerate(oriented_gauss_code[1]):
                     if x == -1:
                         crossing_dic[i + 1] = [d_dic[-(i + 1)][0], d_dic[i + 1][0],
                                                d_dic[-(i + 1)][1], d_dic[i + 1][1]]
@@ -1611,7 +1611,7 @@ class Link(SageObject):
 
         missing = sorted(missing1)
         x = [[] for i in range(len(missing) + 1)]
-        for i,a in enumerate(missing):
+        for i, a in enumerate(missing):
             for j, mlj in enumerate(ml):
                 if mlj != 0 and abs(mlj) < a:
                     x[i].append(mlj)
@@ -2108,7 +2108,7 @@ class Link(SageObject):
                 gens = [g for g in H.gens() if g.order() == infinity or ch.divides(g.order())]
                 l = len(gens)
                 if l:
-                    coeff[(h,d)] = l
+                    coeff[(h, d)] = l
         return L(coeff)
 
     def determinant(self):
@@ -2828,7 +2828,7 @@ class Link(SageObject):
                 if variab is None:
                     variab = 't'
                 # We force the result to be in the symbolic ring because of the expand
-                return jones(SR(variab)**(ZZ(1)/ZZ(4))).expand()
+                return jones(SR(variab)**(ZZ.one() / ZZ(4))).expand()
         elif algorithm == 'jonesrep':
             braid = self.braid()
             # Special case for the trivial knot with no crossings
@@ -3086,14 +3086,14 @@ class Link(SageObject):
         L = LaurentPolynomialRing(ZZ, [var1, var2])
         if len(self._isolated_components()) > 1:
             if normalization == 'lm':
-                fact = L({(1, -1):-1, (-1, -1):-1})
+                fact = L({(1, -1): -1, (-1, -1): -1})
             elif normalization == 'az':
-                fact = L({(1, -1):1, (-1, -1):-1})
+                fact = L({(1, -1): 1, (-1, -1): -1})
             elif normalization == 'vz':
-                fact = L({(1, -1):-1, (-1, -1):1})
+                fact = L({(1, -1): -1, (-1, -1): 1})
             else:
                 raise ValueError('normalization must be either `lm`, `az` or `vz`')
-            fact = fact ** (len(self._isolated_components())-1)
+            fact = fact ** (len(self._isolated_components()) - 1)
             for i in self._isolated_components():
                 fact = fact * Link(i).homfly_polynomial(var1, var2, normalization)
             return fact
@@ -3104,7 +3104,7 @@ class Link(SageObject):
         for comp in ogc[0]:
             s += ' {}'.format(len(comp))
             for cr in comp:
-                s += ' {} {}'.format(abs(cr)-1, sign(cr))
+                s += ' {} {}'.format(abs(cr) - 1, sign(cr))
         for i, cr in enumerate(ogc[1]):
             s += ' {} {}'.format(i, cr)
         from sage.libs.homfly import homfly_polynomial_dict
@@ -3126,7 +3126,7 @@ class Link(SageObject):
             h_az = self.homfly_polynomial(var1=var1, var2=var2, normalization='az')
             a, z = h_az.parent().gens()
             v = ~a
-            return h_az.subs({a:v})
+            return h_az.subs({a: v})
         else:
             raise ValueError('normalization must be either `lm`, `az` or `vz`')
 
@@ -3315,8 +3315,8 @@ class Link(SageObject):
         M = self._coloring_matrix(n=n)
         KM = M.right_kernel_matrix()
         F = FreeModule(M.base_ring(), KM.dimensions()[0])
-        K = [v*KM for v in F]
-        res = set([])
+        K = [v * KM for v in F]
+        res = set()
         arcs = self.arcs('pd')
         for coloring in K:
             colors = sorted(set(coloring))
@@ -3410,7 +3410,7 @@ class Link(SageObject):
         maps = []
         for c in cols:
             t = list(c.values())
-            ims = [b*a**i for i in t]
+            ims = [b * a**i for i in t]
             maps.append(gr.hom(ims))
         return maps
 
@@ -3629,7 +3629,7 @@ class Link(SageObject):
 
         # Special case for the unknot
         if not pd_code:
-            return circle((0,0), ZZ(1)/ZZ(2), color=color, **kwargs)
+            return circle((0, 0), ZZ.one() / ZZ(2), color=color, **kwargs)
 
         # The idea is the same followed in spherogram, but using MLP instead of
         # network flows.
@@ -3655,9 +3655,9 @@ class Link(SageObject):
             Return the flow variable from the source.
             """
             if e > 0:
-                return v[2*edges.index(e)]
+                return v[2 * edges.index(e)]
             else:
-                return v[2*edges.index(-e)+1]
+                return v[2 * edges.index(-e) + 1]
 
         def flow_to_sink(e):
             r"""
@@ -3682,9 +3682,10 @@ class Link(SageObject):
         MLP.solve()
         # we store the result in a vector s packing right bends as negative left ones
         values = MLP.get_values(v, convert=ZZ, tolerance=1e-3)
-        s = [values[2*i] - values[2*i + 1] for i in range(len(edges))]
+        s = [values[2 * i] - values[2 * i + 1] for i in range(len(edges))]
         # segments represents the different parts of the previous edges after bending
-        segments = {e: [(e,i) for i in range(abs(s[edges.index(e)])+1)] for e in edges}
+        segments = {e: [(e, i) for i in range(abs(s[edges.index(e)]) + 1)]
+                    for e in edges}
         pieces = {tuple(i): [i] for j in segments.values() for i in j}
         nregions = []
         for r in regions[:-1]:  # interior regions
@@ -3713,7 +3714,7 @@ class Link(SageObject):
             c = -1
             b = a
             while c != 2:
-                if b == len(badregion)-1:
+                if b == len(badregion) - 1:
                     b = 0
                 else:
                     b += 1
@@ -3741,15 +3742,15 @@ class Link(SageObject):
 
             if a < b:
                 r1 = badregion[:a] + [[badregion[a][0], 0], [N1, 1]] + badregion[b:]
-                r2 = badregion[a + 1:b] + [[N2, 1],[N1, 1]]
+                r2 = badregion[a + 1:b] + [[N2, 1], [N1, 1]]
             else:
                 r1 = badregion[b:a] + [[badregion[a][0], 0], [N1, 1]]
-                r2 = badregion[:b] + [[N2, 1],[N1, 1]] + badregion[a + 1:]
+                r2 = badregion[:b] + [[N2, 1], [N1, 1]] + badregion[a + 1:]
 
             if otherregion:
                 c = [x for x in otherregion if badregion[b][0] == x[0]]
                 c = otherregion.index(c[0])
-                otherregion.insert(c + 1, [N2,otherregion[c][1]])
+                otherregion.insert(c + 1, [N2, otherregion[c][1]])
                 otherregion[c][1] = 0
             nregions.remove(badregion)
             nregions.append(r1)
@@ -3807,7 +3808,7 @@ class Link(SageObject):
                 turn = -1
             else:
                 turn = 1
-            lengthse = [lengths[(e,k)] for k in range(abs(s[edges.index(e)])+1)]
+            lengthse = [lengths[(e, k)] for k in range(abs(s[edges.index(e)]) + 1)]
             if c.index(e) == 0 or (c.index(e) == 3 and orien == 1) or (c.index(e) == 1 and orien == -1):
                 turn = -turn
                 lengthse.reverse()

sage/sandpiles/sandpile.py

@@ -339,7 +339,6 @@ from sage.graphs.digraph import DiGraph
 from sage.graphs.graph import Graph
 from sage.misc.functional import det, denominator
 from sage.misc.lazy_import import lazy_import
-from sage.misc.misc import exists
 from sage.misc.misc_c import prod
 from sage.misc.temporary_file import tmp_filename
 from sage.rings.integer import Integer
@@ -1542,7 +1541,7 @@ class Sandpile(DiGraph):
         else:
             rec = list(self.recurrents())
             for r in self.recurrents():
-                if exists(rec, lambda x: r > x)[0]:
+                if any(r > x for x in rec):
                     rec.remove(r)
         self._min_recurrents = rec
 
@@ -5330,7 +5329,7 @@ class SandpileDivisor(dict):
 
             sage: S = sandpiles.Cycle(6)
             sage: D = SandpileDivisor(S, [0,0,0,0,0,4])         # optional - 4ti2
-            sage: D._set_r_of_D()                               # optional - 4ti2
+            sage: D._set_r_of_D()                               # optional - 4ti2, needs sage.geometry.polyhedron
         """
         eff = self.effective_div()
         n = self._sandpile.num_verts()

sage/topology/cell_complex.py

@@ -545,7 +545,7 @@ class GenericCellComplex(SageObject):
              [0,0] x [0,1] x [0,1] - [0,1] x [0,0] x [0,1] + [0,1] x [0,1] x [0,0]
              - [0,1] x [0,1] x [1,1] + [0,1] x [1,1] x [0,1] - [1,1] x [0,1] x [0,1])]
 
-        Similarly for simpicial sets::
+        Similarly for simplicial sets::
 
             sage: S = simplicial_sets.Sphere(2)
             sage: S.homology(generators=True)                                           # needs sage.modules

sage/topology/cubical_complex.py

@@ -1473,13 +1473,13 @@ class CubicalComplex(GenericCellComplex):
             ...
             NotImplementedError: suspensions are not implemented for cubical complexes
         """
-#         if n<0:
-#             raise ValueError, "n must be nonnegative."
-#         if n==0:
-#             return self
-#         if n==1:
-#             return self.join(cubical_complexes.Sphere(0))
-#         return self.suspension().suspension(int(n-1))
+        # if n < 0:
+        #     raise ValueError("n must be nonnegative")
+        # if n == 0:
+        #     return self
+        # if n == 1:
+        #     return self.join(cubical_complexes.Sphere(0))
+        # return self.suspension().suspension(int(n-1))
         raise NotImplementedError("suspensions are not implemented for cubical complexes")
 
     def product(self, other):

sage/topology/delta_complex.py

@@ -305,7 +305,7 @@ class DeltaComplex(GenericCellComplex):
                     # else a dictionary indexed by simplices
                     dimension = max([f.dimension() for f in data])
                     old_data_by_dim = {}
-                    for dim in range(0, dimension+1):
+                    for dim in range(dimension + 1):
                         old_data_by_dim[dim] = []
                         new_data[dim] = []
                     for x in data:
@@ -467,7 +467,7 @@ class DeltaComplex(GenericCellComplex):
                         new_dict[d+1].append(tuple([translate[n] for n in f]))
                 new_dict[d].append(cells[d][x])
                 cells_to_add.update(cells[d][x])
-        new_cells = [new_dict[n] for n in range(0, max_dim+1)]
+        new_cells = [new_dict[n] for n in range(max_dim + 1)]
         sub = DeltaComplex(new_cells)
         sub._is_subcomplex_of = {self: new_data}
         return sub
@@ -565,7 +565,7 @@ class DeltaComplex(GenericCellComplex):
                 raise ValueError("this is not a subcomplex of self")
         else:
             subcomplex_cells = subcomplex._is_subcomplex_of[self]
-            for d in range(0, max(subcomplex_cells.keys())+1):
+            for d in range(max(subcomplex_cells.keys()) + 1):
                 L = list(cells[d])
                 for c in subcomplex_cells[d]:
                     L[c] = None
@@ -1304,7 +1304,7 @@ class DeltaComplex(GenericCellComplex):
         # added_cells: dict indexed by (n-1)-cells, with value the
         # corresponding new n-cell.
         added_cells = {(): len(cells_dict[0])-1}
-        for n in range(0, dim):
+        for n in range(dim):
             new_cells = {}
             # for each n-cell in the standard simplex, add an
             # (n+1)-cell to the subdivided complex.

sage/topology/simplicial_complex.py

@@ -803,7 +803,7 @@ class Simplex(SageObject):
         """
         return hash(self.__set)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Print representation.
 
@@ -1478,7 +1478,7 @@ class SimplicialComplex(Parent, GenericCellComplex):
         d = self.dimension()
         f = self.f_vector()  # indexed starting at 0, since it's a Python list
         h = []
-        for j in range(0, d + 2):
+        for j in range(d + 2):
             s = 0
             for i in range(-1, j):
                 s += (-1)**(j-i-1) * binomial(d-i, j-i-1) * f[i+1]
@@ -2004,7 +2004,7 @@ class SimplicialComplex(Parent, GenericCellComplex):
                                  rename_vertices=True)
         return self.suspension(1, is_mutable).suspension(int(n-1), is_mutable)
 
-    def disjoint_union(self, right, rename_vertices=None, is_mutable=True):
+    def disjoint_union(self, right, is_mutable=True):
         """
         The disjoint union of this simplicial complex with another one.
 
@@ -2012,14 +2012,6 @@ class SimplicialComplex(Parent, GenericCellComplex):
 
         - ``right`` -- the other simplicial complex (the right-hand factor)
 
-        - ``rename_vertices`` -- boolean (default: ``True``); if this is
-          ``True``, the vertices in the disjoint union will be renamed by the
-          formula: vertex "v" in the left-hand factor --> vertex "Lv" in the
-          disjoint union, vertex "w" in the right-hand factor --> vertex "Rw"
-          in the disjoint union.  If this is false, this tries to construct the
-          disjoint union without renaming the vertices; this will cause
-          problems if the two factors have any vertices with names in common.
-
         EXAMPLES::
 
             sage: S1 = simplicial_complexes.Sphere(1)
@@ -2027,15 +2019,8 @@ class SimplicialComplex(Parent, GenericCellComplex):
             sage: S1.disjoint_union(S2).homology()                                      # needs sage.modules
             {0: Z, 1: Z, 2: Z}
         """
-        if rename_vertices is not None:
-            from sage.misc.superseded import deprecation
-            deprecation(35907, 'the "rename_vertices" argument is deprecated')
-
-        facets = []
-        for f in self._facets:
-            facets.append(tuple(["L" + str(v) for v in f]))
-        for f in right._facets:
-            facets.append(tuple(["R" + str(v) for v in f]))
+        facets = [tuple(f"L{v}" for v in f) for f in self._facets]
+        facets.extend(tuple(f"R{v}" for v in f) for f in right._facets)
         return SimplicialComplex(facets, is_mutable=is_mutable)
 
     def wedge(self, right, rename_vertices=True, is_mutable=True):
@@ -3466,7 +3451,7 @@ class SimplicialComplex(Parent, GenericCellComplex):
         TESTS::
 
             sage: SC = SimplicialComplex([(0,1,2),(0,2,3),(2,3,4),(1,2,4), \
-                                          (1,4,5),(0,3,6),(3,6,7),(4,5,7)])
+            ....:                         (1,4,5),(0,3,6),(3,6,7),(4,5,7)])
 
         This was taking a long time before :issue:`20078`::
 
@@ -4517,7 +4502,7 @@ class SimplicialComplex(Parent, GenericCellComplex):
 
     # this function overrides the standard one for GenericCellComplex,
     # because it lists the maximal faces, not the total number of faces.
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Print representation.