passagemath-graphs 10.5.43__cp312-cp312-macosx_14_0_arm64.whl → 10.6.1rc2__cp312-cp312-macosx_14_0_arm64.whl

sage/graphs/centrality.pyx

@@ -24,6 +24,8 @@ from cysignals.signals cimport sig_check
 from memory_allocator cimport MemoryAllocator
 
 from sage.data_structures.bitset_base cimport *
+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 *
 from sage.libs.gmp.mpq cimport *
 from sage.rings.rational cimport Rational
@@ -116,6 +118,19 @@ def centrality_betweenness(G, bint exact=False, bint normalize=True):
         {0: 0.0, 1: 0.0}
         sage: centrality_betweenness(Graph(2), exact=1)
         {0: 0, 1: 0}
+
+    The method is valid for 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.centrality_betweenness() == H.centrality_betweenness()
+        True
+        sage: G.centrality_betweenness(exact=True) == H.centrality_betweenness(exact=True)
+        True
     """
     if exact:
         return centrality_betweenness_C(G, <mpq_t> 0, normalize=normalize)
@@ -147,12 +162,13 @@ cdef dict centrality_betweenness_C(G, numerical_type _, bint normalize=True):
         return {v: zero for v in G}
 
     # A copy of G, for faster neighbor enumeration
+    cdef StaticSparseCGraph cg
     cdef short_digraph g
 
     # A second copy, to remember the edges used during the BFS (see doc)
     cdef short_digraph bfs_dag
 
-    cdef list int_to_vertex = list(G)
+    cdef list int_to_vertex
 
     cdef int n = G.order()
 
@@ -179,7 +195,14 @@ cdef dict centrality_betweenness_C(G, numerical_type _, bint normalize=True):
         mpq_init(mpq_tmp)
 
     try:
-        init_short_digraph(g, G, edge_labelled=False, vertex_list=int_to_vertex)
+        if isinstance(G, StaticSparseBackend):
+            cg = <StaticSparseCGraph> G._cg
+            g = <short_digraph> cg.g
+            int_to_vertex = cg._vertex_to_labels
+        else:
+            int_to_vertex = list(G)
+            init_short_digraph(g, G, edge_labelled=False, vertex_list=int_to_vertex)
+
         init_reverse(bfs_dag, g)
 
         queue = <uint32_t*> check_allocarray(n, sizeof(uint32_t))
@@ -305,7 +328,8 @@ cdef dict centrality_betweenness_C(G, numerical_type _, bint normalize=True):
             mpq_clear(mpq_tmp)
 
     finally:
-        free_short_digraph(g)
+        if not isinstance(G, StaticSparseBackend):
+            free_short_digraph(g)
         free_short_digraph(bfs_dag)
         bitset_free(seen)
         bitset_free(next_layer)
@@ -459,6 +483,8 @@ cdef void _estimate_reachable_vertices_dir(short_digraph g, int* reachL, int* re
         reachL[i] = reachL_scc[scc[i]]
         reachU[i] = min(<int>reachU_scc[scc[i]], g.n)
 
+    free_short_digraph(sccgraph)
+
 
 cdef void _compute_reachable_vertices_undir(short_digraph g, int* reachable) noexcept:
     r"""
@@ -668,6 +694,19 @@ def centrality_closeness_top_k(G, int k=1, int verbose=0):
         True
         sage: all(abs(topk[i][0] - sorted_centr[i]) < 1e-12 for i in range(len(topk)))
         True
+
+    Immutable graphs::
+
+        sage: from sage.graphs.centrality import centrality_closeness_top_k
+        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: k = randint(1, 10)
+        sage: centrality_closeness_top_k(G, k) == centrality_closeness_top_k(H, k)
+        True
     """
     cdef list res
     if k >= G.order():
@@ -685,12 +724,19 @@ def centrality_closeness_top_k(G, int k=1, int verbose=0):
         return []
 
     cdef MemoryAllocator mem = MemoryAllocator()
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
     # 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 V = list(G)
-    init_short_digraph(sd, G, edge_labelled=False, vertex_list=V)
+    cdef list V
+    if isinstance(G, StaticSparseBackend):
+        cg = <StaticSparseCGraph> G._cg
+        sd = <short_digraph> cg.g
+        V = cg._vertex_to_labels
+    else:
+        V = list(G)
+        init_short_digraph(sd, G, edge_labelled=False, vertex_list=V)
     cdef int n = sd.n
     cdef int* reachL = <int*> mem.malloc(n * sizeof(int))
     cdef int* reachU
@@ -825,6 +871,9 @@ def centrality_closeness_top_k(G, int k=1, int verbose=0):
     if verbose > 0:
         print("Final performance ratio: {}".format(visited / (n * <double> (sd.neighbors[sd.n] - sd.edges))))
 
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
+
     res = [(1.0 / farness[v], V[v]) for v in topk[:k] if v != -1]
     try:
         res = sorted(res, reverse=True)
@@ -885,6 +934,18 @@ def centrality_closeness_random_k(G, int k=1):
         Traceback (most recent call last):
         ...
         ValueError: G must be an undirected Graph
+
+    The method is valid for immutable graphs::
+
+        sage: from sage.graphs.centrality import centrality_closeness_random_k
+        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: centrality_closeness_random_k(G, 10) == centrality_closeness_random_k(H, 10)
+        True
     """
     G._scream_if_not_simple()
     if G.is_directed():
@@ -906,13 +967,21 @@ def centrality_closeness_random_k(G, int k=1):
     cdef double* partial_farness = <double*> mem.malloc(n * sizeof(double))
     cdef uint32_t* distance
     cdef uint32_t* waiting_list
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
     cdef bitset_t seen
     cdef double farness
     cdef int i, j
     cdef dict closeness_centrality_array = {}
-    cdef list int_to_vertex = list(G)
-    cdef dict vertex_to_int = {v: i for i, v in enumerate(int_to_vertex)}
+    cdef list int_to_vertex
+    cdef dict vertex_to_int
+    if isinstance(G, StaticSparseBackend):
+        cg = <StaticSparseCGraph> G._cg
+        int_to_vertex = cg._vertex_to_labels
+        vertex_to_int = cg._vertex_to_int
+    else:
+        int_to_vertex = list(G)
+        vertex_to_int = {v: i for i, v in enumerate(int_to_vertex)}
 
     # Initialize
     for i in range(n):
@@ -940,7 +1009,10 @@ def centrality_closeness_random_k(G, int k=1):
         # Copying the whole graph as a static_sparse_graph for fast shortest
         # paths computation in unweighted graph. This data structure is well
         # documented in module sage.graphs.base.static_sparse_graph
-        init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_vertex)
+        if isinstance(G, StaticSparseBackend):
+            sd = <short_digraph> cg.g
+        else:
+            init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_vertex)
         distance = <uint32_t*> mem.malloc(n * sizeof(uint32_t))
         waiting_list = <uint32_t*> mem.malloc(n * sizeof(uint32_t))
         bitset_init(seen, n)
@@ -956,7 +1028,8 @@ def centrality_closeness_random_k(G, int k=1):
             closeness_centrality_array[int_to_vertex[V[i]]] = (n - 1) / farness
 
         bitset_free(seen)
-        free_short_digraph(sd)
+        if not isinstance(G, StaticSparseBackend):
+            free_short_digraph(sd)
 
     # Estimate the closeness centrality for remaining n-k vertices.
     for i in range(k, n):

sage/graphs/cographs.py

@@ -399,7 +399,7 @@ def change_label(tree, status, counter):
 
     - ``tree`` -- the tree to relabel
 
-    - ``status`` -- boolean; used to to detect series (``True``) and parallel
+    - ``status`` -- boolean; used to detect series (``True``) and parallel
       (``False``) internal nodes
 
     - ``counter`` -- list; the first integer of the list is used to assign a

sage/graphs/comparability.pyx

@@ -200,8 +200,18 @@ Methods
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from cysignals.memory cimport sig_free
-from sage.graphs.distances_all_pairs cimport c_distances_all_pairs
+from libc.stdint cimport uint32_t
+from memory_allocator cimport MemoryAllocator
+
+from sage.data_structures.bitset_base cimport *
+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 (short_digraph,
+                                                   init_short_digraph,
+                                                   free_short_digraph,
+                                                   simple_BFS,
+                                                   out_degree)
+
 from copy import copy
 
 
@@ -748,14 +758,17 @@ def is_permutation(g, algorithm='greedy', certificate=False, check=True,
 
 def is_transitive(g, certificate=False):
     r"""
-    Test whether the digraph is transitive.
+    Check whether the digraph is transitive.
 
     A digraph is transitive if for any pair of vertices `u,v\in G` linked by a
     `uv`-path the edge `uv` belongs to `G`.
 
     INPUT:
 
-    - ``certificate`` -- whether to return a certificate for negative answers
+    - ``g`` -- a digraph
+
+    - ``certificate`` -- boolean (default: ``False``); whether to return a
+      certificate for negative answers
 
       - If ``certificate = False`` (default), this method returns ``True`` or
         ``False`` according to the graph.
@@ -784,30 +797,55 @@ def is_transitive(g, certificate=False):
         True
     """
     cdef int n = g.order()
-
     if n <= 2:
         return True
 
-    cdef list int_to_vertex = list(g)
-    cdef unsigned short * distances = c_distances_all_pairs(g, vertex_list=int_to_vertex)
-    cdef unsigned short * c_distances = distances
-
-    cdef int i, j
-
-    # Only 3 distances can appear in the matrix of all distances : 0, 1, and
-    # infinity. Anything else is a proof of nontransitivity !
-
-    for j in range(n):
-        for i in range(n):
-            if c_distances[i] != <unsigned short> -1 and c_distances[i] > 1:
-                sig_free(distances)
-                if certificate:
-
-                    return int_to_vertex[j], int_to_vertex[i]
-                else:
-                    return False
-
-        c_distances += n
+    # 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
+    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)
+
+    cdef MemoryAllocator mem = MemoryAllocator()
+    cdef uint32_t * distances = <uint32_t *> mem.malloc(n * sizeof(uint32_t))
+    cdef uint32_t * waiting_list = <uint32_t *> mem.malloc(n * sizeof(uint32_t))
+    cdef bitset_t seen
+    bitset_init(seen, n)
+
+    cdef uint32_t u, v
+    cdef int i
+
+    for u in range(n):
+
+        # 1. perform a breadth first search from u
+        _ = simple_BFS(sd, u, distances, NULL, waiting_list, seen)
+
+        # 2. Check whether the BFS reaches vertices that are not in the closed
+        # neighborhood of u.
+        if bitset_len(seen) != out_degree(sd, u) + 1:
+            if certificate:
+                bitset_discard(seen, u)
+                for i in range(out_degree(sd, u)):
+                    bitset_discard(seen, sd.neighbors[u][i])
+                v = bitset_first(seen)
+
+            bitset_free(seen)
+            if not isinstance(g, StaticSparseBackend):
+                free_short_digraph(sd)
+            if certificate:
+                return (int_to_vertex[u], int_to_vertex[v])
+            return False
+
+    bitset_free(seen)
+    if not isinstance(g, StaticSparseBackend):
+        free_short_digraph(sd)
 
-    sig_free(distances)
     return True

sage/graphs/convexity_properties.pyx

@@ -41,6 +41,8 @@ from sage.graphs.distances_all_pairs cimport c_distances_all_pairs
 from cysignals.memory cimport sig_free
 from memory_allocator cimport MemoryAllocator
 from libc.stdint cimport uint32_t
+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 (short_digraph,
                                                    init_short_digraph,
                                                    free_short_digraph,
@@ -573,6 +575,17 @@ def geodetic_closure(G, S):
         Traceback (most recent call last):
         ...
         NotImplementedError: the geodetic closure of digraphs has not been implemented yet
+
+    The method is valid for 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: geodetic_closure(G, [0, 3]) == geodetic_closure(H, [0, 3])
+        True
     """
     if G.is_directed():
         raise NotImplementedError("the geodetic closure of digraphs has not been implemented yet")
@@ -592,13 +605,23 @@ def geodetic_closure(G, S):
 
     cdef int n = G.order()
     cdef int nS = len(S)
-    cdef list int_to_vertex = list(G)
-    cdef dict vertex_to_int = {u: i for i, u in enumerate(int_to_vertex)}
-    cdef list S_int = [vertex_to_int[u] for u in S]
+    cdef list int_to_vertex
+    cdef dict vertex_to_int
 
     # Copy the graph as a short digraph
+    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
+        vertex_to_int = cg._vertex_to_int
+    else:
+        int_to_vertex = list(G)
+        vertex_to_int = {u: i for i, u in enumerate(int_to_vertex)}
+        init_short_digraph(sd, G, edge_labelled=False, vertex_list=int_to_vertex)
+
+    cdef list S_int = [vertex_to_int[u] for u in S]
 
     # Allocate some data structures
     cdef MemoryAllocator mem = MemoryAllocator()
@@ -669,7 +692,8 @@ def geodetic_closure(G, S):
     bitset_free(seen)
     bitset_free(visited)
     bitset_free(closure)
-    free_short_digraph(sd)
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
 
     return ret
 
@@ -746,6 +770,17 @@ def is_geodetic(G):
         sage: G.add_edge(G.random_edge())
         sage: G.is_geodetic()
         False
+
+    The method is valid for 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.is_geodetic() == H.is_geodetic()
+        True
     """
     if G.has_multiple_edges():
         return False
@@ -755,15 +790,21 @@ def is_geodetic(G):
 
     # Copy the graph as a short digraph
     cdef int n = G.order()
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
-    init_short_digraph(sd, G, edge_labelled=False, vertex_list=list(G))
+    if isinstance(G, StaticSparseBackend):
+        cg = <StaticSparseCGraph> G._cg
+        sd = <short_digraph> cg.g
+    else:
+        init_short_digraph(sd, G, edge_labelled=False, vertex_list=list(G))
 
     # Allocate some data structures
     cdef MemoryAllocator mem = MemoryAllocator()
     cdef uint32_t * distances = <uint32_t *> mem.malloc(n * sizeof(uint32_t))
     cdef uint32_t * waiting_list = <uint32_t *> mem.malloc(n * sizeof(uint32_t))
     if not distances or not waiting_list:
-        free_short_digraph(sd)
+        if not isinstance(G, StaticSparseBackend):
+            free_short_digraph(sd)
         raise MemoryError()
     cdef bitset_t seen
     bitset_init(seen, n)
@@ -812,7 +853,8 @@ def is_geodetic(G):
                 elif distances[u] == distances[v] + 1:
                     # G is not geodetic
                     bitset_free(seen)
-                    free_short_digraph(sd)
+                    if not isinstance(G, StaticSparseBackend):
+                        free_short_digraph(sd)
                     return False
 
                 p_tmp += 1
@@ -821,7 +863,8 @@ def is_geodetic(G):
             waiting_beginning += 1
 
     bitset_free(seen)
-    free_short_digraph(sd)
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
 
     # The graph is geodetic
     return True