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

sage/graphs/strongly_regular_db.pyx

@@ -112,9 +112,9 @@ def is_mathon_PC_srg(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_mathon_PC_srg
         sage: t = is_mathon_PC_srg(45,22,10,11); t                                      # needs sage.libs.pari
         (..., 1)
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.pari
+        sage: g = t[0](*t[1:]); g                                                       # needs database_graphs sage.libs.pari
         Mathon's PC SRG on 45 vertices: Graph on 45 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.pari
+        sage: g.is_strongly_regular(parameters=True)                                    # needs database_graphs sage.libs.pari
         (45, 22, 10, 11)
 
     TESTS::
@@ -360,9 +360,9 @@ def is_affine_polar(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_affine_polar
         sage: t = is_affine_polar(81,32,13,12); t                                       # needs sage.rings.finite_rings
         (..., 4, 3)
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.rings.finite_rings
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.rings.finite_rings
         Affine Polar Graph VO^+(4,3): Graph on 81 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.rings.finite_rings
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.rings.finite_rings
         (81, 32, 13, 12)
 
         sage: t = is_affine_polar(5,5,5,5); t
@@ -415,9 +415,9 @@ def is_orthogonal_polar(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_orthogonal_polar
         sage: t = is_orthogonal_polar(85, 20, 3, 5); t
         (<function OrthogonalPolarGraph at ...>, 5, 4, '')
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.rings.finite_rings
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.rings.finite_rings
         Orthogonal Polar Graph O(5, 4): Graph on 85 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.rings.finite_rings
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.rings.finite_rings
         (85, 20, 3, 5)
 
         sage: t = is_orthogonal_polar(5,5,5,5); t                                       # needs sage.rings.finite_rings
@@ -571,9 +571,9 @@ def is_NOodd(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_NOodd
         sage: t = is_NOodd(120, 51, 18, 24); t                                          # needs sage.libs.pari
         (<function NonisotropicOrthogonalPolarGraph at ...>, 5, 4, '-')
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.pari
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.libs.pari
         NO^-(5, 4): Graph on 120 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.pari
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.libs.pari
         (120, 51, 18, 24)
 
     TESTS:
@@ -642,9 +642,9 @@ def is_NOperp_F5(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_NOperp_F5
         sage: t = is_NOperp_F5(10, 3, 0, 1); t                                          # needs sage.libs.pari
         (<function NonisotropicOrthogonalPolarGraph at ...>, 3, 5, '-', 1)
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.pari
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.libs.pari
         NO^-,perp(3, 5): Graph on 10 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.pari
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.libs.pari
         (10, 3, 0, 1)
 
     TESTS:
@@ -697,9 +697,9 @@ def is_NO_F2(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_NO_F2
         sage: t = is_NO_F2(10, 3, 0, 1); t                                              # needs sage.libs.pari
         (<function NonisotropicOrthogonalPolarGraph at ...>, 4, 2, '-')
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.pari
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.libs.pari
         NO^-(4, 2): Graph on 10 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.pari
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.libs.pari
         (10, 3, 0, 1)
 
     TESTS:
@@ -748,9 +748,9 @@ def is_NO_F3(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_NO_F3
         sage: t = is_NO_F3(15, 6, 1, 3); t                                              # needs sage.libs.pari
         (<function NonisotropicOrthogonalPolarGraph at ...>, 4, 3, '-')
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.pari
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.libs.pari
         NO^-(4, 3): Graph on 15 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.pari
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.libs.pari
         (15, 6, 1, 3)
 
     TESTS:
@@ -804,9 +804,9 @@ def is_NU(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_NU
         sage: t = is_NU(40, 27, 18, 18); t                                              # needs sage.libs.pari
         (<function NonisotropicUnitaryPolarGraph at ...>, 4, 2)
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.pari
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.libs.pari
         NU(4, 2): Graph on 40 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.pari
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.libs.pari
         (40, 27, 18, 18)
 
     TESTS::
@@ -1069,25 +1069,25 @@ def is_polhill(int v, int k, int l, int mu):
     # We now define the P_{i,j}. see section 6.
 
     P = {}
-    P[0,1] = list(range((-1) + 1                  , 2**(s-2)+1))
-    P[1,1] = list(range((-1) + 2**(s-2)+2         , 2**(s-1)+1))
-    P[2,1] = list(range((-1) + 2**(s-1)+2         , 2**(s-1)+2**(s-2)+1))
-    P[3,1] = list(range((-1) + 2**(s-1)+2**(s-2)+2, 2**(s)+1))
-
-    P[0,2] = list(range((-1) + 2**(s-2)+2         , 2**(s-1)+2))
-    P[1,2] = list(range((-1) + 2**(s-1)+3         , 2**(s-1)+2**(s-2)+2))
-    P[2,2] = list(range((-1) + 2**(s-1)+2**(s-2)+3, 2**(s)+1)) + [0]
-    P[3,2] = list(range((-1) + 2                  , 2**(s-2)+1))
-
-    P[0,3] = list(range((-1) + 2**(s-1)+3         , 2**(s-1)+2**(s-2)+3))
-    P[1,3] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1)) + [0,1]
-    P[2,3] = list(range((-1) + 3                  , 2**(s-2)+2))
-    P[3,3] = list(range((-1) + 2**(s-2)+3         , 2**(s-1)+2))
-
-    P[0,4] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1))
-    P[1,4] = list(range((-1) + 3                  , 2**(s-2)+1)) + [2**(s-1)+1,2**(s-1)+2**(s-2)+2]
-    P[2,4] = list(range((-1) + 2**(s-2)+3         , 2**(s-1)+1)) + [2**(s-1)+2**(s-2)+1,1]
-    P[3,4] = list(range((-1) + 2**(s-1)+3         , 2**(s-1)+2**(s-2)+1)) + [2**(s-2)+1,0]
+    P[0, 1] = list(range((-1) + 1, 2**(s-2)+1))
+    P[1, 1] = list(range((-1) + 2**(s-2)+2, 2**(s-1)+1))
+    P[2, 1] = list(range((-1) + 2**(s-1)+2, 2**(s-1)+2**(s-2)+1))
+    P[3, 1] = list(range((-1) + 2**(s-1)+2**(s-2)+2, 2**(s)+1))
+
+    P[0, 2] = list(range((-1) + 2**(s-2)+2, 2**(s-1)+2))
+    P[1, 2] = list(range((-1) + 2**(s-1)+3, 2**(s-1)+2**(s-2)+2))
+    P[2, 2] = list(range((-1) + 2**(s-1)+2**(s-2)+3, 2**(s)+1)) + [0]
+    P[3, 2] = list(range((-1) + 2, 2**(s-2)+1))
+
+    P[0, 3] = list(range((-1) + 2**(s-1)+3, 2**(s-1)+2**(s-2)+3))
+    P[1, 3] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1)) + [0,1]
+    P[2, 3] = list(range((-1) + 3, 2**(s-2)+2))
+    P[3, 3] = list(range((-1) + 2**(s-2)+3, 2**(s-1)+2))
+
+    P[0, 4] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1))
+    P[1, 4] = list(range((-1) + 3, 2**(s-2)+1)) + [2**(s-1)+1,2**(s-1)+2**(s-2)+2]
+    P[2, 4] = list(range((-1) + 2**(s-2)+3, 2**(s-1)+1)) + [2**(s-1)+2**(s-2)+1,1]
+    P[3, 4] = list(range((-1) + 2**(s-1)+3, 2**(s-1)+2**(s-2)+1)) + [2**(s-2)+1,0]
 
     R = {x: copy(P[x]) for x in P}
 
@@ -1101,10 +1101,10 @@ def is_polhill(int v, int k, int l, int mu):
 
     # We now define the R_{i,j}. see *end* of section 6.
 
-    R[0,3] = list(range((-1) + 2**(s-1)+3         , 2**(s-1)+2**(s-2)+2))
-    R[1,3] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1)) + [0,1,2**(s-1)+2**(s-2)+2]
-    R[0,4] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1)) + [2**(s-1)+2**(s-2)+2]
-    R[1,4] = list(range((-1) + 3                  , 2**(s-2)+1)) + [2**(s-1)+1]
+    R[0, 3] = list(range((-1) + 2**(s-1)+3, 2**(s-1)+2**(s-2)+2))
+    R[1, 3] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1)) + [0,1,2**(s-1)+2**(s-2)+2]
+    R[0, 4] = list(range((-1) + 2**(s-1)+2**(s-2)+4, 2**(s)+1)) + [2**(s-1)+2**(s-2)+2]
+    R[1, 4] = list(range((-1) + 3, 2**(s-2)+1)) + [2**(s-1)+1]
 
     for x in R:
         R[x] = [K[i] for i in R[x]]
@@ -1273,9 +1273,9 @@ def is_unitary_polar(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_unitary_polar
         sage: t = is_unitary_polar(45, 12, 3, 3); t                                     # needs sage.libs.pari
         (<function UnitaryPolarGraph at ...>, 4, 2)
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.pari
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap sage.libs.pari
         Unitary Polar Graph U(4, 2); GQ(4, 2): Graph on 45 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.pari
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap sage.libs.pari
         (45, 12, 3, 3)
 
         sage: t = is_unitary_polar(5,5,5,5); t                                          # needs sage.libs.pari
@@ -1351,9 +1351,9 @@ def is_unitary_dual_polar(int v, int k, int l, int mu):
         sage: from sage.graphs.strongly_regular_db import is_unitary_dual_polar
         sage: t = is_unitary_dual_polar(297, 40, 7, 5); t
         (<function UnitaryDualPolarGraph at ...>, 5, 2)
-        sage: g = t[0](*t[1:]); g
+        sage: g = t[0](*t[1:]); g                                                       # needs sage.libs.gap
         Unitary Dual Polar Graph DU(5, 2); GQ(8, 4): Graph on 297 vertices
-        sage: g.is_strongly_regular(parameters=True)
+        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.libs.gap
         (297, 40, 7, 5)
         sage: t = is_unitary_dual_polar(5,5,5,5); t
 
@@ -1492,11 +1492,11 @@ def is_twograph_descendant_of_srg(int v, int k0, int l, int mu):
     EXAMPLES::
 
         sage: from sage.graphs.strongly_regular_db import is_twograph_descendant_of_srg
-        sage: t = is_twograph_descendant_of_srg(27, 10, 1, 5); t                        # needs sage.rings.finite_rings
+        sage: t = is_twograph_descendant_of_srg(27, 10, 1, 5); t                        # needs database_graphs sage.rings.finite_rings
         (<cyfunction is_twograph_descendant_of_srg.<locals>.la at...
-        sage: g = t[0](*t[1:]); g                                                       # needs sage.rings.finite_rings
+        sage: g = t[0](*t[1:]); g                                                       # needs database_graphs sage.rings.finite_rings
         descendant of complement(Johnson graph with parameters 8,2) at {0, 1}: Graph on 27 vertices
-        sage: g.is_strongly_regular(parameters=True)                                    # needs sage.rings.finite_rings
+        sage: g.is_strongly_regular(parameters=True)                                    # needs database_graphs sage.rings.finite_rings
         (27, 10, 1, 5)
         sage: t = is_twograph_descendant_of_srg(5,5,5,5); t
 
@@ -1961,9 +1961,9 @@ def SRG_105_32_4_12():
     EXAMPLES::
 
         sage: from sage.graphs.strongly_regular_db import SRG_105_32_4_12
-        sage: G = SRG_105_32_4_12(); G                                                  # needs sage.rings.finite_rings
+        sage: G = SRG_105_32_4_12(); G                                                  # needs sage.groups sage.rings.finite_rings
         Aut L(3,4) on flags: Graph on 105 vertices
-        sage: G.is_strongly_regular(parameters=True)                                    # needs sage.rings.finite_rings
+        sage: G.is_strongly_regular(parameters=True)                                    # needs sage.groups sage.rings.finite_rings
         (105, 32, 4, 12)
     """
     from sage.combinat.designs.block_design import ProjectiveGeometryDesign
@@ -2804,7 +2804,7 @@ def strongly_regular_graph(int v, int k, int l, int mu=-1, bint existence=False,
 
     Petersen's graph from its set of parameters::
 
-        sage: graphs.strongly_regular_graph(10,3,0,1,existence=True)                    # needs sage.libs.pari
+        sage: graphs.strongly_regular_graph(10,3,0,1, existence=True)                   # needs database_graphs sage.libs.pari
         True
         sage: graphs.strongly_regular_graph(10,3,0,1)           # needs database_graphs
         complement(Johnson graph with parameters 5,2): Graph on 10 vertices
@@ -2868,7 +2868,7 @@ def strongly_regular_graph(int v, int k, int l, int mu=-1, bint existence=False,
         descendant of (540, 264, 138, 120)-strongly regular graph at ... 539 vertices
         sage: graphs.strongly_regular_graph(539, 250, 105, 125)                         # needs sage.combinat
         descendant of (540, 275, 130, 150)-strongly regular graph at ... 539 vertices
-        sage: graphs.strongly_regular_graph(209, 100, 45, 50)                           # needs sage.libs.pari
+        sage: graphs.strongly_regular_graph(209, 100, 45, 50)                           # needs database_graphs sage.libs.pari
         descendant of complement(merging of S_7 on Circulant(6,[1,4])s) at ... 209 vertices
 
 
@@ -2886,6 +2886,7 @@ def strongly_regular_graph(int v, int k, int l, int mu=-1, bint existence=False,
 
     `\mu=0` behaves correctly (:issue:`19712`)::
 
+        sage: # needs database_graphs
         sage: graphs.strongly_regular_graph(10,2,1)
         Traceback (most recent call last):
         ...
@@ -3070,7 +3071,7 @@ def apparently_feasible_parameters(int n):
          (16, 9, 4, 6),
          (16, 10, 6, 6),
          (17, 8, 3, 4)}
-        sage: all(graphs.strongly_regular_graph(*x,existence=True) is True              # needs sage.libs.pari
+        sage: all(graphs.strongly_regular_graph(*x,existence=True) is True              # needs database_graphs sage.libs.pari
         ....:     for x in small_feasible)
         True
 
@@ -3078,7 +3079,7 @@ def apparently_feasible_parameters(int n):
     `(49,16,3,6)`-strongly regular graph)::
 
         sage: small_feasible = apparently_feasible_parameters(60)
-        sage: all(graphs.strongly_regular_graph(*x,existence=True) is True              # needs sage.libs.pari
+        sage: all(graphs.strongly_regular_graph(*x,existence=True) is True              # needs database_graphs sage.libs.pari
         ....:     for x in small_feasible)
         False
     """
@@ -3114,6 +3115,7 @@ def _build_small_srg_database():
     Make sure that all two-weight codes yield the strongly regular graphs we
     expect::
 
+        sage: # needs database_graphs
         sage: graphs.strongly_regular_graph(81, 50, 31, 30)                             # needs sage.libs.pari
         complement(two-intersection set in PG(4,3)): Graph on 81 vertices
         sage: graphs.strongly_regular_graph(243, 220, 199, 200)                 # long time, needs sage.rings.finite_rings

sage/graphs/traversals.pyx

@@ -1,6 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # cython: binding=True
 # distutils: language = c++
+# distutils: extra_compile_args = -std=c++11
 r"""
 Graph traversals
 
@@ -64,16 +65,17 @@ from collections import deque
 
 from libc.string cimport memset
 from libc.stdint cimport uint32_t
-from libcpp.queue cimport priority_queue
-from libcpp.pair cimport pair
 from libcpp.vector cimport vector
 from cysignals.signals cimport sig_on, sig_off
 from memory_allocator cimport MemoryAllocator
 
+from sage.data_structures.pairing_heap cimport PairingHeap_of_n_integers
+from sage.graphs.base.c_graph cimport CGraph, CGraphBackend
+from sage.graphs.base.static_sparse_backend cimport StaticSparseCGraph
+from sage.graphs.base.static_sparse_backend cimport StaticSparseBackend
 from sage.graphs.base.static_sparse_graph cimport init_short_digraph
 from sage.graphs.base.static_sparse_graph cimport free_short_digraph
 from sage.graphs.base.static_sparse_graph cimport out_degree
-from sage.graphs.base.c_graph cimport CGraph, CGraphBackend
 from sage.graphs.graph_decompositions.slice_decomposition cimport \
         extended_lex_BFS
 
@@ -754,8 +756,7 @@ def lex_M(self, triangulation=False, labels=False, initial_vertex=None, algorith
     - ``labels`` -- boolean (default: ``False``); whether to return the labels
       assigned to each vertex
 
-    - ``initial_vertex`` -- (default: ``None``) the first vertex to
-      consider
+    - ``initial_vertex`` -- (default: ``None``); the first vertex to consider
 
     - ``algorithm`` -- string (default: ``None``); one of the following
       algorithms:
@@ -821,6 +822,18 @@ def lex_M(self, triangulation=False, labels=False, initial_vertex=None, algorith
         sage: g.lex_M()
         [6, 4, 5, 3, 2, 1]
 
+    The ordering depends on the initial vertex::
+
+        sage: G = graphs.HouseGraph()
+        sage: G.lex_M(algorithm='lex_M_slow', initial_vertex=0)
+        [4, 3, 2, 1, 0]
+        sage: G.lex_M(algorithm='lex_M_slow', initial_vertex=2)
+        [1, 4, 3, 0, 2]
+        sage: G.lex_M(algorithm='lex_M_fast', initial_vertex=0)
+        [4, 3, 2, 1, 0]
+        sage: G.lex_M(algorithm='lex_M_fast', initial_vertex=2)
+        [1, 4, 3, 0, 2]
+
     TESTS:
 
     ``'lex_M_fast'`` cannot return labels::
@@ -1128,6 +1141,18 @@ def lex_M_fast(G, triangulation=False, initial_vertex=None):
         Traceback (most recent call last):
         ...
         ValueError: 'foo' is not a graph vertex
+
+    Immutable graphs::
+
+        sage: from sage.graphs.traversals import lex_M_fast
+        sage: G = graphs.RandomGNP(10, .7)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = Graph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: lex_M_fast(G) == lex_M_fast(H)
+        True
     """
     if initial_vertex is not None and initial_vertex not in G:
         raise ValueError("'{}' is not a graph vertex".format(initial_vertex))
@@ -1137,16 +1162,19 @@ def lex_M_fast(G, triangulation=False, initial_vertex=None):
 
     # ==> Initialization
 
-    cdef list int_to_v = list(G)
     cdef int i, j, k, v, w, z
 
-    if initial_vertex is not None:
-        # We put the initial vertex at first place in the ordering
-        i = int_to_v.index(initial_vertex)
-        int_to_v[0], int_to_v[i] = int_to_v[i], int_to_v[0]
-
+    cdef list int_to_v
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
-    init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_v)
+    if isinstance(G, StaticSparseBackend):
+        cg = <StaticSparseCGraph> G._cg
+        sd = <short_digraph> cg.g
+        int_to_v = cg._vertex_to_labels
+    else:
+        int_to_v = list(G)
+        init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_v)
+
     cdef uint32_t* p_tmp
     cdef uint32_t* p_end
 
@@ -1154,6 +1182,11 @@ def lex_M_fast(G, triangulation=False, initial_vertex=None):
 
     cdef list unnumbered_vertices = list(range(n))
 
+    if initial_vertex is not None:
+        # We put the initial vertex at the first place
+        i = int_to_v.index(initial_vertex)
+        unnumbered_vertices[0], unnumbered_vertices[i] = unnumbered_vertices[i], unnumbered_vertices[0]
+
     cdef MemoryAllocator mem = MemoryAllocator()
     cdef int* label = <int*>mem.allocarray(n, sizeof(int))
     cdef int* alpha = <int*>mem.allocarray(n, sizeof(int))
@@ -1238,7 +1271,8 @@ def lex_M_fast(G, triangulation=False, initial_vertex=None):
                     k += 2
                 label[w] = k
 
-    free_short_digraph(sd)
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
 
     cdef list ordering = [int_to_v[alpha[i]] for i in range(n)]
 
@@ -1355,9 +1389,9 @@ def maximum_cardinality_search(G, reverse=False, tree=False, initial_vertex=None
         sage: G.maximum_cardinality_search(initial_vertex=0)
         [3, 2, 1, 0]
         sage: G.maximum_cardinality_search(initial_vertex=1)
-        [0, 3, 2, 1]
+        [3, 2, 0, 1]
         sage: G.maximum_cardinality_search(initial_vertex=2)
-        [0, 1, 3, 2]
+        [0, 3, 1, 2]
         sage: G.maximum_cardinality_search(initial_vertex=3)
         [0, 1, 2, 3]
         sage: G.maximum_cardinality_search(initial_vertex=3, reverse=True)
@@ -1389,6 +1423,17 @@ def maximum_cardinality_search(G, reverse=False, tree=False, initial_vertex=None
         Traceback (most recent call last):
         ...
         ValueError: vertex (17) is not a vertex of the graph
+
+    Immutable graphs;:
+
+        sage: G = graphs.RandomGNP(10, .7)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = Graph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: G.maximum_cardinality_search() == H.maximum_cardinality_search()
+        True
     """
     if tree:
         from sage.graphs.digraph import DiGraph
@@ -1399,17 +1444,27 @@ def maximum_cardinality_search(G, reverse=False, tree=False, initial_vertex=None
     if N == 1:
         return (list(G), DiGraph(G)) if tree else list(G)
 
-    cdef list int_to_vertex = list(G)
+    cdef list int_to_vertex
+    cdef StaticSparseCGraph cg
+    cdef short_digraph sd
+    if isinstance(G, StaticSparseBackend):
+        cg = <StaticSparseCGraph> G._cg
+        sd = <short_digraph> cg.g
+        int_to_vertex = cg._vertex_to_labels
+    else:
+        int_to_vertex = list(G)
+        init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_vertex)
 
     if initial_vertex is None:
         initial_vertex = 0
     elif initial_vertex in G:
-        initial_vertex = int_to_vertex.index(initial_vertex)
+        if isinstance(G, StaticSparseBackend):
+            initial_vertex = cg._vertex_to_int[initial_vertex]
+        else:
+            initial_vertex = int_to_vertex.index(initial_vertex)
     else:
         raise ValueError("vertex ({0}) is not a vertex of the graph".format(initial_vertex))
 
-    cdef short_digraph sd
-    init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_vertex)
     cdef uint32_t** p_vertices = sd.neighbors
     cdef uint32_t* p_tmp
     cdef uint32_t* p_end
@@ -1421,27 +1476,18 @@ def maximum_cardinality_search(G, reverse=False, tree=False, initial_vertex=None
 
     cdef int i, u, v
     for i in range(N):
-        weight[i] = 0
-        seen[i] = False
         pred[i] = i
 
-    # We emulate a heap with decrease key operation using a priority queue.
-    # A vertex can be inserted multiple times (up to its degree), but only the
-    # first extraction (with maximum weight) matters. The size of the queue will
-    # never exceed O(m).
-    cdef priority_queue[pair[int, int]] pq
-    pq.push((0, initial_vertex))
+    # We emulate a max-heap data structure using a min-heap with negative values
+    cdef PairingHeap_of_n_integers P = PairingHeap_of_n_integers(N)
+    P.push(initial_vertex, 0)
 
     # The ordering alpha is feed in reversed order and revert afterword
     cdef list alpha = []
 
-    while not pq.empty():
-        _, u = pq.top()
-        pq.pop()
-        if seen[u]:
-            # We use a lazy decrease key mode, so u can be several times in pq
-            continue
-
+    while P:
+        u = P.top_item()
+        P.pop()
         alpha.append(int_to_vertex[u])
         seen[u] = True
 
@@ -1451,12 +1497,13 @@ def maximum_cardinality_search(G, reverse=False, tree=False, initial_vertex=None
             v = p_tmp[0]
             if not seen[v]:
                 weight[v] += 1
-                pq.push((weight[v], v))
+                P.decrease(v, -weight[v])
                 if pred[v] == v:
                     pred[v] = u
             p_tmp += 1
 
-    free_short_digraph(sd)
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
 
     if len(alpha) < N:
         raise ValueError("the input graph is not connected")
@@ -1763,16 +1810,18 @@ def maximum_cardinality_search_M(G, initial_vertex=None):
         Traceback (most recent call last):
         ...
         ValueError: vertex (17) is not a vertex of the graph
-    """
-    cdef list int_to_vertex = list(G)
 
-    if initial_vertex is None:
-        initial_vertex = 0
-    elif initial_vertex in G:
-        initial_vertex = int_to_vertex.index(initial_vertex)
-    else:
-        raise ValueError("vertex ({0}) is not a vertex of the graph".format(initial_vertex))
+    Immutable graphs::
 
+        sage: G = graphs.RandomGNP(10, .7)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = Graph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: G.maximum_cardinality_search_M() == H.maximum_cardinality_search_M()
+        True
+    """
     cdef int N = G.order()
     if not N:
         return ([], [], [])
@@ -1782,8 +1831,26 @@ def maximum_cardinality_search_M(G, initial_vertex=None):
     # Copying the whole graph to obtain the list of neighbors quicker than by
     # calling out_neighbors. This data structure is well documented in the
     # module sage.graphs.base.static_sparse_graph
+    cdef list int_to_vertex
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
-    init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_vertex)
+    if isinstance(G, StaticSparseBackend):
+        cg = <StaticSparseCGraph> G._cg
+        sd = <short_digraph> cg.g
+        int_to_vertex = cg._vertex_to_labels
+    else:
+        int_to_vertex = list(G)
+        init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_vertex)
+
+    if initial_vertex is None:
+        initial_vertex = 0
+    elif initial_vertex in G:
+        if isinstance(G, StaticSparseBackend):
+            initial_vertex = cg._vertex_to_int[initial_vertex]
+        else:
+            initial_vertex = int_to_vertex.index(initial_vertex)
+    else:
+        raise ValueError("vertex ({0}) is not a vertex of the graph".format(initial_vertex))
 
     cdef MemoryAllocator mem = MemoryAllocator()
     cdef int* alpha = <int*>mem.calloc(N, sizeof(int))
@@ -1795,7 +1862,8 @@ def maximum_cardinality_search_M(G, initial_vertex=None):
     maximum_cardinality_search_M_short_digraph(sd, initial_vertex, alpha, alpha_inv, F, X)
     sig_off()
 
-    free_short_digraph(sd)
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
 
     cdef int u, v
     return ([int_to_vertex[alpha[u]] for u in range(N)],

sage/knots/free_knotinfo_monoid.py

@@ -340,8 +340,7 @@ class FreeKnotInfoMonoid(IndexedFreeAbelianMonoid):
                 if SymmetryMutant.concordance_inverse in hp_sym.keys():
                     hp_sym[SymmetryMutant.concordance_inverse] = hpm
 
-            for sym_mut in hp_sym.keys():
-                hps = hp_sym[sym_mut]
+            for sym_mut, hps in hp_sym.items():
                 if hps.divides(hpoly):
                     Kgen = self((K, sym_mut))
                     h = hpoly // hps
@@ -376,7 +375,7 @@ class FreeKnotInfoMonoid(IndexedFreeAbelianMonoid):
             sage: from sage.knots.free_knotinfo_monoid import FreeKnotInfoMonoid
             sage: FKIM =  FreeKnotInfoMonoid()
             sage: K = KnotInfo.K5_1.link().mirror_image()
-            sage: FKIM._from_knot(K)                                                    # needs sage.modules
+            sage: FKIM._from_knot(K)                                                    # needs sage.groups sage.modules
             (KnotInfo['K5_1m'],)
         """
         hp = knot.homfly_polynomial(normalization='vz')

sage/knots/knot.py

@@ -293,7 +293,7 @@ class Knot(Link, Element, metaclass=InheritComparisonClasscallMetaclass):
                     crossing = i
                     break
             if not string_found:
-                for i in range(0, crossing):
+                for i in range(crossing):
                     if abs(b[i]) == string or abs(b[i]) == string - 1:
                         string_found = True
                         crossing = i

sage/knots/knotinfo.py

@@ -18,7 +18,7 @@ package using
 This will install a `Python wrapper <https://github.com/soehms/database_knotinfo#readme>`__
 for the original databases in Sage. This wrapper perfoms an automatic progress
 of version numbers. For more details and further install instructions please see
-the correspondig web-page.
+the corresponding web-page.
 
 To perform all the doctests concerning the usage of the database on the installation
 add the option ``-c``. In this case (for instance ``sage -f -c database_knotinfo``)
@@ -219,7 +219,7 @@ AUTHORS:
 - Sebastian Oehms August 2020: initial version
 - Sebastian Oehms June   2022: add :meth:`conway_polynomial` and :meth:`khovanov_polynomial` (:issue:`33969`)
 
-Thanks to Chuck Livingston and Allison Moore for their support. For further acknowledgments see the correspondig hompages.
+Thanks to Chuck Livingston and Allison Moore for their support. For further acknowledgments see the corresponding hompages.
 """
 
 
@@ -230,7 +230,7 @@ Thanks to Chuck Livingston and Allison Moore for their support. For further ackn
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 ##############################################################################
 
 
@@ -1428,7 +1428,7 @@ class KnotInfoBase(Enum):
 
             sage: H = KnotInfo.L11n459_1_1_1.homfly_polynomial()   # optional - database_knotinfo
             sage: all(L.homfly_polynomial() == L.link().homfly_polynomial(normalization='vz')\
-                      for L in KnotInfo if L.crossing_number() < 7)
+            ....:     for L in KnotInfo if L.crossing_number() < 7)
             True
 
         REFERENCES: