passagemath-graphs 10.5.43__cp311-cp311-macosx_14_0_arm64.whl → 10.6.1rc2__cp311-cp311-macosx_14_0_arm64.whl

sage/databases/knotinfo_db.py

@@ -578,13 +578,14 @@ class KnotInfoDataBase(SageObject, UniqueRepresentation):
     def _create_data_sobj(self, sobj_path=None):
         r"""
         Create ``sobj`` files containing the contents of the whole table.
+
         To each column there is created one file containing a list of
         strings giving the entries of the database table.
 
         The length of these lists depends on the type of the corresponding
         column. If a column is used in both tables
         (``KnotInfoColumnTypes.KnotsAndLinks``) the list of proper links
-        is appended to the list of knots.  In both other cases the lenght
+        is appended to the list of knots.  In both other cases the length
         of the list corresponds to the number of listed knots and proper
         links respectively.
 

sage/graphs/asteroidal_triples.pyx

@@ -66,6 +66,8 @@ from cysignals.signals cimport sig_on, sig_off
 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
 
 
@@ -125,6 +127,17 @@ def is_asteroidal_triple_free(G, certificate=False):
         Traceback (most recent call last):
         ...
         ValueError: The first parameter must be a Graph.
+
+    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_asteroidal_triple_free() == H.is_asteroidal_triple_free()
+        True
     """
     from sage.graphs.graph import Graph
     if not isinstance(G, Graph):
@@ -146,9 +159,16 @@ def is_asteroidal_triple_free(G, certificate=False):
     # 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 = list(G)
+    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)
 
     cdef bitset_t seen
     bitset_init(seen, n)
@@ -169,7 +189,8 @@ def is_asteroidal_triple_free(G, certificate=False):
     finally:
         # Release memory
         bitset_free(seen)
-        free_short_digraph(sd)
+        if not isinstance(G, StaticSparseBackend):
+            free_short_digraph(sd)
 
     # ==> We return the result
 

sage/graphs/base/boost_graph.pxd

@@ -2,14 +2,14 @@
 # distutils: language = c++
 # distutils: extra_compile_args = -std=c++11
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2015 Michele Borassi michele.borassi@imtlucca.it
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  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/
+# ***************************************************************************
 from libcpp.vector cimport vector
 from libcpp.pair cimport pair
 

sage/graphs/base/c_graph.pyx

@@ -954,7 +954,7 @@ cdef class CGraph:
         self.check_vertex(u)
         self.check_vertex(v)
         if unlikely(self.in_degrees is NULL or self.out_degrees is NULL):
-            raise ValueError("`self.in_degree` or `self.out_degree` not allocated")
+            raise ValueError("`self.in_degrees` or `self.out_degrees` not allocated")
         if self.in_degrees[v] < self.out_degrees[u]:
             size = self.in_degrees[v]
         else:

sage/graphs/base/dense_graph.pxd

@@ -1,13 +1,13 @@
 # sage_setup: distribution = sagemath-graphs
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2008-2009 Robert L. Miller <rlmillster@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # 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/
+# ***************************************************************************
 
 from sage.graphs.base.c_graph cimport CGraph, CGraphBackend
 from sage.data_structures.binary_matrix cimport binary_matrix_t
@@ -17,6 +17,8 @@ cdef class DenseGraph(CGraph):
     cdef binary_matrix_t edges
     cdef inline int _add_arc_unsafe(self, int, int) except -1
     cdef inline int _del_arc_unsafe(self, int u, int v) except -1
+    cpdef int out_degree(self, int u) noexcept
+    cpdef int in_degree(self, int u) noexcept
 
 cdef int copy_dense_graph(DenseGraph dest, DenseGraph src) except -1
 

sage/graphs/base/dense_graph.pyx

@@ -453,6 +453,50 @@ cdef class DenseGraph(CGraph):
             i = bitset_next(self.active_vertices, i + 1)
         return -1
 
+    cpdef int out_degree(self, int u) noexcept:
+        """
+        Return the out-degree of ``v``
+
+        INPUT:
+
+        - ``u`` -- integer
+
+        EXAMPLES::
+
+            sage: from sage.graphs.base.dense_graph import DenseGraph
+            sage: G = DenseGraph(5)
+            sage: G.add_arc(0,1)
+            sage: G.add_arc(1,2)
+            sage: G.add_arc(1,3)
+            sage: G.out_degree(0)
+            1
+            sage: G.out_degree(1)
+            2
+        """
+        return self.out_degrees[u]
+
+    cpdef int in_degree(self, int v) noexcept:
+        """
+        Return the in-degree of ``v``
+
+        INPUT:
+
+        - ``v`` -- integer
+
+        EXAMPLES::
+
+            sage: from sage.graphs.base.dense_graph import DenseGraph
+            sage: G = DenseGraph(5)
+            sage: G.add_arc(0,1)
+            sage: G.add_arc(1,2)
+            sage: G.add_arc(1,3)
+            sage: G.in_degree(0)
+            0
+            sage: G.in_degree(1)
+            1
+        """
+        return self.in_degrees[v]
+
 
 cdef int copy_dense_graph(DenseGraph dest, DenseGraph src) except -1:
     r"""

sage/graphs/base/static_sparse_backend.pyx

@@ -36,6 +36,7 @@ Classes and methods
 -------------------
 """
 
+cimport cython
 from cysignals.memory cimport check_calloc, sig_free
 
 from sage.graphs.base.static_sparse_graph cimport (init_short_digraph,
@@ -125,6 +126,8 @@ cdef class StaticSparseCGraph(CGraph):
                 self.number_of_loops = <int *>check_calloc(self.g.n, sizeof(int))
             except MemoryError:
                 free_short_digraph(self.g)
+                if self._directed:
+                    free_short_digraph(self.g_rev)
                 raise
             for i in range(self.g.n):
                 for tmp in range(out_degree(self.g, i)):
@@ -140,7 +143,7 @@ cdef class StaticSparseCGraph(CGraph):
         bitset_set_first_n(self.active_vertices, self.g.n)
 
         self.num_verts = self.g.n
-        self.num_arcs = self.g.m
+        self.num_arcs = self.g.m if self._directed else (2 * self.g.m)
 
     def __dealloc__(self):
         r"""
@@ -394,7 +397,7 @@ cdef class StaticSparseCGraph(CGraph):
         if u < 0 or u >= self.g.n:
             raise LookupError("the vertex does not belong to the graph")
 
-        return self.g.neighbors[u+1] - self.g.neighbors[u]
+        return out_degree(self.g, u)
 
     cpdef int in_degree(self, int u) except -1:
         r"""
@@ -419,9 +422,8 @@ cdef class StaticSparseCGraph(CGraph):
             raise LookupError("the vertex does not belong to the graph")
 
         if not self._directed:
-            return self.g.neighbors[u+1] - self.g.neighbors[u]
-        else:
-            return self.g_rev.neighbors[u+1] - self.g_rev.neighbors[u]
+            return out_degree(self.g, u)
+        return out_degree(self.g_rev, u)
 
 
 cdef class StaticSparseBackend(CGraphBackend):
@@ -1545,6 +1547,7 @@ cdef class StaticSparseBackend(CGraphBackend):
         (<StaticSparseCGraph> self._cg).del_vertex(v)
 
 
+@cython.binding(True)
 def _run_it_on_static_instead(f):
     r"""
     A decorator function to force the (Di)Graph functions to compute from a

sage/graphs/base/static_sparse_graph.pyx

@@ -281,10 +281,9 @@ cdef int init_short_digraph(short_digraph g, G, edge_labelled=False,
     g.m = G.size()
 
     cdef int isdigraph = G.is_directed()
-    cdef uint32_t i, v_id, j
+    cdef uint32_t i, j
     cdef list vertices = vertex_list if vertex_list is not None else list(G)
     cdef dict v_to_id = {v: i for i, v in enumerate(vertices)}
-    cdef list neighbor_label
     cdef list edge_labels
     # Loops are not stored twice for undirected graphs
     cdef int n_edges = g.m if isdigraph else 2*g.m - G.number_of_loops()
@@ -803,21 +802,43 @@ def tarjan_strongly_connected_components(G):
         ....:      s2 = Set(map(Set,scc2))
         ....:      if s1 != s2:
         ....:          print("Ooch !")
+
+    Immutable digraphs::
+
+        sage: from sage.graphs.base.static_sparse_graph import tarjan_strongly_connected_components
+        sage: G = digraphs.RandomDirectedGNP(10, .4)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = DiGraph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: tarjan_strongly_connected_components(G) == tarjan_strongly_connected_components(H)
+        True
     """
     from sage.graphs.digraph import DiGraph
 
     if not isinstance(G, DiGraph):
         raise ValueError("G must be a DiGraph.")
 
-    cdef MemoryAllocator mem = MemoryAllocator()
-    cdef list int_to_vertex = list(G)
+    cdef list int_to_vertex
+    cdef StaticSparseCGraph cg
     cdef short_digraph g
-    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)
+
+    cdef MemoryAllocator mem = MemoryAllocator()
     cdef int * scc = <int*> mem.malloc(g.n * sizeof(int))
     sig_on()
     cdef int nscc = tarjan_strongly_connected_components_C(g, scc)
     sig_off()
-    free_short_digraph(g)
+
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(g)
 
     cdef int i
     cdef list output = [[] for i in range(nscc)]
@@ -873,6 +894,7 @@ cdef void strongly_connected_components_digraph_C(short_digraph g, int nscc, int
 
     output.n = nscc
     output.m = m
+    output.edge_labels = NULL
 
     output.neighbors = <uint32_t **> check_allocarray((1+<int>output.n), sizeof(uint32_t *))
 
@@ -921,15 +943,37 @@ def strongly_connected_components_digraph(G):
         ....:     for e in g.edges(sort=False):
         ....:         assert(sccs[e[0]]==sccs[e[1]] or scc_digraph.has_edge(sccs[e[0]],sccs[e[1]]))
         ....:         assert(sccs[e[0]] >= sccs[e[1]])
+
+    Immutable digraphs::
+
+        sage: from sage.graphs.base.static_sparse_graph import strongly_connected_components_digraph
+        sage: G = digraphs.RandomDirectedGNP(10, .4)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = DiGraph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: A = strongly_connected_components_digraph(G)[0]
+        sage: B = strongly_connected_components_digraph(H)[0]
+        sage: A.is_isomorphic(B)
+        True
     """
     from sage.graphs.digraph import DiGraph
     if not isinstance(G, DiGraph):
         raise ValueError("G must be a DiGraph.")
 
-    cdef MemoryAllocator mem = MemoryAllocator()
-    cdef list int_to_vertex = list(G)
+    cdef list int_to_vertex
+    cdef StaticSparseCGraph cg
     cdef short_digraph g, scc_g
-    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)
+
+    cdef MemoryAllocator mem = MemoryAllocator()
     cdef int * scc = <int*> mem.malloc(g.n * sizeof(int))
     cdef int i, j, nscc
     cdef list edges = []
@@ -945,7 +989,11 @@ def strongly_connected_components_digraph(G):
             edges.append((i, scc_g.neighbors[i][j]))
     output.add_edges(edges)
     sig_off()
-    free_short_digraph(g)
+
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(g)
+    free_short_digraph(scc_g)
+
     return output, {v: scc[i] for i, v in enumerate(int_to_vertex)}
 
 
@@ -969,7 +1017,8 @@ cdef void free_short_digraph(short_digraph g) noexcept:
     """
     sig_free(g.edges)
     sig_free(g.neighbors)
-    cpython.Py_XDECREF(g.edge_labels)
+    if g.edge_labels != NULL:
+        cpython.Py_XDECREF(g.edge_labels)
 
 
 def triangles_count(G):
@@ -987,14 +1036,35 @@ def triangles_count(G):
         {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0}
         sage: sum(triangles_count(graphs.CompleteGraph(15)).values()) == 3*binomial(15,3)           # needs sage.symbolic
         True
+
+    TESTS:
+
+    Immutable graphs::
+
+        sage: from sage.graphs.base.static_sparse_graph import triangles_count
+        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: triangles_count(G) == triangles_count(H)
+        True
     """
     from sage.rings.integer import Integer
     G._scream_if_not_simple()
 
     # g is a copy of G. If G is internally a static sparse graph, we use it.
-    cdef list int_to_vertex = list(G)
+    cdef list int_to_vertex
+    cdef StaticSparseCGraph cg
     cdef short_digraph g
-    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)
 
     cdef uint64_t * count = <uint64_t *> check_calloc(G.order(), sizeof(uint64_t))
 
@@ -1028,7 +1098,8 @@ def triangles_count(G):
 
     ans = {w: Integer(count[i] // 2) for i, w in enumerate(int_to_vertex)}
 
-    free_short_digraph(g)
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(g)
     sig_free(count)
     return ans
 
@@ -1112,7 +1183,7 @@ def spectral_radius(G, prec=1e-10):
         sage: while not G.is_strongly_connected():
         ....:     shuffle(r)
         ....:     G.add_edges(enumerate(r), loops=False)
-        sage: spectral_radius(G, 1e-10)  # random
+        sage: spectral_radius(G, 1e-10)  # random  # long time
         (1.9997956006500042, 1.9998043797692782)
 
     The algorithm takes care of multiple edges::

sage/graphs/bipartite_graph.py

@@ -392,6 +392,17 @@ class BipartiteGraph(Graph):
             Traceback (most recent call last):
             ...
             LookupError: vertex (7) is not a vertex of the graph
+
+        Check that :issue:`39295` is fixed::
+
+            sage: # needs sage.modules
+            sage: B = BipartiteGraph(matrix([[1, 1], [1, 1]]), immutable=True)
+            sage: print(B.vertices(), B.edges())
+            [0, 1, 2, 3] [(0, 2, None), (0, 3, None), (1, 2, None), (1, 3, None)]
+            sage: B.add_vertices([4], left=True)
+            Traceback (most recent call last):
+            ...
+            ValueError: graph is immutable; please change a copy instead (use function copy())
         """
         if kwds is None:
             kwds = {'loops': False}
@@ -468,32 +479,31 @@ class BipartiteGraph(Graph):
             if kwds.get("multiedges", False) and kwds.get("weighted", False):
                 raise TypeError("weighted multi-edge bipartite graphs from "
                                 "reduced adjacency matrix not supported")
-            Graph.__init__(self, *args, **kwds)
             ncols = data.ncols()
             nrows = data.nrows()
             self.left = set(range(ncols))
             self.right = set(range(ncols, nrows + ncols))
 
-            # ensure that the vertices exist even if there
-            # are no associated edges (trac #10356)
-            self.add_vertices(self.left)
-            self.add_vertices(self.right)
-
-            if kwds.get("multiedges", False):
-                for ii in range(ncols):
-                    for jj in range(nrows):
-                        if data[jj, ii]:
-                            self.add_edges([(ii, jj + ncols)] * data[jj, ii])
-            elif kwds.get("weighted", False):
-                for ii in range(ncols):
-                    for jj in range(nrows):
-                        if data[jj, ii]:
-                            self.add_edge((ii, jj + ncols, data[jj, ii]))
-            else:
-                for ii in range(ncols):
-                    for jj in range(nrows):
-                        if data[jj, ii]:
-                            self.add_edge((ii, jj + ncols))
+            def edges():
+                if kwds.get("multiedges", False):
+                    for ii in range(ncols):
+                        for jj in range(nrows):
+                            for _ in range(data[jj, ii]):
+                                yield (ii, jj + ncols)
+                elif kwds.get("weighted", False):
+                    for ii in range(ncols):
+                        for jj in range(nrows):
+                            if data[jj, ii]:
+                                yield (ii, jj + ncols, data[jj, ii])
+                else:
+                    for ii in range(ncols):
+                        for jj in range(nrows):
+                            if data[jj, ii]:
+                                yield (ii, jj + ncols)
+
+            # ensure that construction works
+            # when immutable=True (issue #39295)
+            Graph.__init__(self, data=[range(nrows + ncols), edges()], format='vertices_and_edges', *args, **kwds)
         else:
             if partition is not None:
                 left, right = set(partition[0]), set(partition[1])
@@ -2457,12 +2467,8 @@ class BipartiteGraph(Graph):
 
         B.add_edges(edges_to_keep)
 
-        attributes_to_update = ('_pos', '_assoc')
-        for attr in attributes_to_update:
-            if hasattr(self, attr) and getattr(self, attr) is not None:
-                d = getattr(self, attr)
-                value = {v: d.get(v, None) for v in B}
-                setattr(B, attr, value)
+        B._copy_attribute_from(self, '_pos')
+        B._copy_attribute_from(self, '_assoc')
 
         return B
 
@@ -2521,12 +2527,8 @@ class BipartiteGraph(Graph):
         else:
             # We make a copy of the graph
             B = BipartiteGraph(data=self.edges(sort=True), partition=[self.left, self.right])
-            attributes_to_update = ('_pos', '_assoc')
-            for attr in attributes_to_update:
-                if hasattr(self, attr) and getattr(self, attr) is not None:
-                    d = getattr(self, attr)
-                    value = {v: d.get(v, None) for v in B}
-                    setattr(B, attr, value)
+            B._copy_attribute_from(self, '_pos')
+            B._copy_attribute_from(self, '_assoc')
         B.name("Subgraph of ({})".format(self.name()))
 
         vertices = set(vertices)
@@ -2551,7 +2553,8 @@ class BipartiteGraph(Graph):
         return B
 
     def canonical_label(self, partition=None, certificate=False,
-                        edge_labels=False, algorithm=None, return_graph=True):
+                        edge_labels=False, algorithm=None, return_graph=True,
+                        immutable=None):
         r"""
         Return the canonical graph.
 
@@ -2592,6 +2595,10 @@ class BipartiteGraph(Graph):
           instead of the canonical graph. Only available when ``'bliss'``
           is explicitly set as algorithm.
 
+        - ``immutable`` -- boolean (default: ``None``); whether to create a
+          mutable/immutable (di)graph. ``immutable=None`` (default) means that
+          the (di)graph and its canonical (di)graph will behave the same way.
+
         EXAMPLES::
 
             sage: B = BipartiteGraph( [(0, 4), (0, 5), (0, 6), (0, 8), (1, 5),
@@ -2651,6 +2658,19 @@ class BipartiteGraph(Graph):
             sage: B.canonical_label()
             Bipartite multi-graph on 4 vertices
 
+        Check the behavior for immutable graphs::
+
+            sage: G = BipartiteGraph(graphs.CycleGraph(4))
+            sage: G.canonical_label().is_immutable()
+            False
+            sage: G.canonical_label(immutable=True).is_immutable()
+            True
+            sage: G = BipartiteGraph(graphs.CycleGraph(4), immutable=True)
+            sage: G.canonical_label().is_immutable()
+            True
+            sage: G.canonical_label(immutable=False).is_immutable()
+            False
+
         .. SEEALSO::
 
             :meth:`~sage.graphs.generic_graph.GenericGraph.canonical_label()`
@@ -2660,7 +2680,8 @@ class BipartiteGraph(Graph):
                                                    certificate=certificate,
                                                    edge_labels=edge_labels,
                                                    algorithm=algorithm,
-                                                   return_graph=return_graph)
+                                                   return_graph=return_graph,
+                                                   immutable=immutable)
 
         else:
             from sage.groups.perm_gps.partn_ref.refinement_graphs import search_tree
@@ -2699,7 +2720,9 @@ class BipartiteGraph(Graph):
                 a, b, c = search_tree(GC, partition, certificate=True, dig=False)
                 cert = {v: c[G_to[v]] for v in G_to}
 
-            C = self.relabel(perm=cert, inplace=False)
+            if immutable is None:
+                immutable = self.is_immutable()
+            C = self.relabel(perm=cert, inplace=False, immutable=immutable)
 
         C.left = {cert[v] for v in self.left}
         C.right = {cert[v] for v in self.right}