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

sage/graphs/graph_decompositions/clique_separators.pyx

@@ -26,6 +26,8 @@ from libc.stdint cimport uint32_t
 from cysignals.signals cimport sig_on, sig_off, sig_check
 from memory_allocator cimport MemoryAllocator
 
+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
 from sage.graphs.base.static_sparse_graph cimport init_short_digraph
 from sage.graphs.base.static_sparse_graph cimport free_short_digraph
@@ -414,6 +416,17 @@ def atoms_and_clique_separators(G, tree=False, rooted_tree=False, separators=Fal
             {1}   _{}_
                  /   /
                 {3} {2}
+
+    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.atoms_and_clique_separators() == H.atoms_and_clique_separators()
+        True
     """
     cdef list A = []   # atoms
     cdef list Sh = []  # separators
@@ -453,13 +466,20 @@ def atoms_and_clique_separators(G, tree=False, rooted_tree=False, separators=Fal
         return A, Sc
 
     cdef int N = G.order()
-    cdef list int_to_vertex = list(G)
 
     # 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)
 
     # variables for the manipulation of the short digraph
     cdef uint32_t** p_vertices = sd.neighbors
@@ -575,7 +595,8 @@ def atoms_and_clique_separators(G, tree=False, rooted_tree=False, separators=Fal
                 for u in Cint:
                     active[u] = False
 
-    free_short_digraph(sd)
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
     H.clear()
 
     # We add the last atom

sage/graphs/graph_decompositions/fast_digraph.pyx

@@ -91,7 +91,7 @@ cdef class FastDigraph:
 
     def print_adjacency_matrix(self):
         r"""
-        Displays the adjacency matrix of ``self``.
+        Display the adjacency matrix of ``self``.
 
         EXAMPLES::
 

sage/graphs/graph_decompositions/graph_products.pyx

@@ -132,7 +132,7 @@ Methods
 # ****************************************************************************
 
 
-def is_cartesian_product(g, certificate=False, relabeling=False):
+def is_cartesian_product(g, certificate=False, relabeling=False, immutable=None):
     r"""
     Test whether the graph is a Cartesian product.
 
@@ -149,6 +149,10 @@ def is_cartesian_product(g, certificate=False, relabeling=False):
       product graph. If `g` is not a Cartesian product, ``None`` is returned
       instead.
 
+    - ``immutable`` -- boolean (default: ``None``); whether to create a
+      mutable/immutable graph. ``immutable=None`` (default) means that the
+      graph and its factors will behave the same way.
+
     .. SEEALSO::
 
         - :meth:`sage.graphs.generic_graph.GenericGraph.cartesian_product`
@@ -217,6 +221,19 @@ def is_cartesian_product(g, certificate=False, relabeling=False):
         False
         sage: Graph({0:[]}).is_cartesian_product()
         False
+
+    Check the behaviour of parameter ``immutable``::
+
+        sage: G = graphs.Grid2dGraph(3, 3)
+        sage: any(f.is_immutable() for f in G.is_cartesian_product(certificate=True))
+        False
+        sage: all(f.is_immutable() for f in G.is_cartesian_product(certificate=True, immutable=True))
+        True
+        sage: G = G.copy(immutable=True)
+        sage: all(f.is_immutable() for f in G.is_cartesian_product(certificate=True))
+        True
+        sage: any(f.is_immutable() for f in G.is_cartesian_product(certificate=True, immutable=False))
+        False
     """
     g._scream_if_not_simple()
     if g.is_directed():
@@ -316,11 +333,13 @@ def is_cartesian_product(g, certificate=False, relabeling=False):
     if len(edges) == 1:
         return (False, None) if relabeling else False
 
+    if immutable is None:
+        immutable = g.is_immutable()
+
     # Building the list of factors
     cdef list factors = []
     for cc in edges:
-        tmp = Graph()
-        tmp.add_edges(cc)
+        tmp = Graph(cc, format='list_of_edges', immutable=immutable)
         factors.append(tmp.subgraph(vertices=tmp.connected_components(sort=False)[0]))
 
     # Computing the product of these graphs
@@ -338,11 +357,10 @@ def is_cartesian_product(g, certificate=False, relabeling=False):
         return isiso, dictt
     if certificate:
         return factors
-    else:
-        return True
+    return True
 
 
-def rooted_product(G, H, root=None):
+def rooted_product(G, H, root=None, immutable=None):
     r"""
     Return the rooted product of `G` and `H`.
 
@@ -369,6 +387,15 @@ def rooted_product(G, H, root=None):
         - :mod:`~sage.graphs.graph_decompositions.graph_products`
           -- a module on graph products
 
+    INPUT:
+
+    - ``G, H`` -- two (di)graphs
+
+    - ``immutable`` -- boolean (default: ``None``); whether to create a
+      mutable/immutable (di)graph. When ``immutable=None`` (default) the rooted
+      product will be mutable if one of ``G`` or ``H`` is mutable and immutable
+      otherwise.
+
     EXAMPLES:
 
     The rooted product of two trees is a tree::
@@ -433,30 +460,49 @@ def rooted_product(G, H, root=None):
         Traceback (most recent call last):
         ...
         TypeError: the graphs should be both directed or both undirected
+
+    Check the behaviour of parameter ``immutable``::
+
+        sage: G = graphs.CycleGraph(4)
+        sage: H = graphs.PathGraph(3)
+        sage: G.rooted_product(H).is_immutable()
+        False
+        sage: G.rooted_product(H, immutable=True).is_immutable()
+        True
+        sage: G = G.copy(immutable=True)
+        sage: G.rooted_product(H).is_immutable()
+        False
+        sage: G.rooted_product(H, immutable=True).is_immutable()
+        True
+        sage: H = H.copy(immutable=True)
+        sage: G.rooted_product(H).is_immutable()
+        True
+        sage: G.rooted_product(H, immutable=False).is_immutable()
+        False
     """
     G._scream_if_not_simple(allow_loops=True)
-    if G._directed and H._directed:
-        from sage.graphs.digraph import DiGraph
-        R = DiGraph(loops=(G.has_loops() or H.has_loops()))
-    elif (not G._directed) and (not H._directed):
-        from sage.graphs.graph import Graph
-        R = Graph(loops=(G.has_loops() or H.has_loops()))
-    else:
+    if G._directed is not H._directed:
         raise TypeError('the graphs should be both directed or both undirected')
 
-    R.name(f'Rooted product of {G} and {H}')
+    loops = G.has_loops() or H.has_loops()
+    name = f'Rooted product of {G} and {H}'
+    if immutable is None:
+        immutable = G.is_immutable() and H.is_immutable()
 
     if not G or not H:
-        return R
+        return G.parent()(loops=loops, name=name, immutable=immutable)
     if root is None:
         root = next(H.vertex_iterator())
     elif root not in H:
         raise ValueError("the specified root is not a vertex of H")
 
-    R.add_vertices((u, x) for u in G for x in H)
-    for u, v in G.edge_iterator(labels=False):
-        R.add_edge((u, root), (v, root))
-    for x, y in H.edge_iterator(labels=False):
-        R.add_edges(((u, x), (u, y)) for u in G)
+    vertices = ((u, x) for u in G for x in H)
+
+    def edges():
+        for u, v in G.edge_iterator(labels=False):
+            yield ((u, root), (v, root))
+        for x, y in H.edge_iterator(labels=False):
+            yield from (((u, x), (u, y)) for u in G)
 
-    return R
+    return G.parent()([vertices, edges()], format='vertices_and_edges',
+                      name=name, loops=loops, immutable=immutable)

sage/graphs/graph_decompositions/slice_decomposition.pyx

@@ -28,6 +28,7 @@ AUTHORS:
 # ****************************************************************************
 
 from libcpp.algorithm cimport swap
+from cysignals.signals cimport sig_on, sig_off
 from cython.operator cimport dereference as deref
 
 from sage.graphs.base.c_graph cimport CGraphBackend
@@ -156,6 +157,19 @@ cdef void extended_lex_BFS(
         [0[1[2]] [3] [4]]
         sage: G.lex_BFS(algorithm="fast")
         [0, 1, 2, 3, 4]
+
+    Check that :issue:`39934` is fixed::
+
+        sage: G = Graph(graphs.HouseGraph(), immutable=True)
+        sage: G.slice_decomposition()
+        [0[1[2]] [3] [4]]
+        sage: G.lex_BFS(algorithm="fast")
+        [0, 1, 2, 3, 4]
+        sage: G = Graph(graphs.HouseGraph(), sparse=False)
+        sage: G.slice_decomposition()
+        [0[1[2]] [3] [4]]
+        sage: G.lex_BFS(algorithm="fast")
+        [0, 1, 2, 3, 4]
     """
     cdef int n = <int> cg.num_verts
     # Variables for the partition refinement algorithm
@@ -182,6 +196,7 @@ cdef void extended_lex_BFS(
         deref(xslice_len).resize(n)
         part_len.resize(max_nparts)
     if lex_label != NULL:
+        deref(lex_label).clear()
         deref(lex_label).resize(n)
 
     # Initialize the position of vertices in sigma (and compute max_degree)
@@ -197,7 +212,7 @@ cdef void extended_lex_BFS(
                 sigma[i] = v_int
                 deref(sigma_inv)[v_int] = i
                 i = i + 1
-            max_degree = max(max_degree, cg.out_degrees[v_int])
+            max_degree = max(max_degree, cg.out_degree(v_int))
 
     # Variables needed to iterate over neighbors of a vertex
     cdef int nneighbors
@@ -226,7 +241,7 @@ cdef void extended_lex_BFS(
         v_int = sigma[i]
 
         # Iterate over the neighbors of v
-        nneighbors = cg.out_neighbors_unsafe (v_int, neighbors.data(), max_degree)
+        nneighbors = cg.out_neighbors_unsafe(v_int, neighbors.data(), max_degree)
         for k in range(nneighbors):
             u_int = neighbors[k]
             j = deref(sigma_inv)[u_int]  # get the position of u
@@ -234,7 +249,7 @@ cdef void extended_lex_BFS(
                 continue  # already taken care of
 
             if lex_label != NULL:
-                deref(lex_label)[j].push_back (v_int)
+                deref(lex_label)[j].push_back(v_int)
 
             p = part_of[j]  # get the part of u
             l = part_head[p]  # get the beginning of the part containing u
@@ -339,6 +354,14 @@ def slice_decomposition(G, initial_vertex=None):
         Traceback (most recent call last):
         ...
         ValueError: parameter G must be an undirected graph
+
+    TESTS:
+
+    Check that :issue:`39934` is fixed::
+
+        sage: G = Graph(graphs.HouseGraph(), immutable=True)
+        sage: G.slice_decomposition()
+        [0[1[2]] [3] [4]]
     """
     return SliceDecomposition(G, initial_vertex=initial_vertex)
 
@@ -410,14 +433,17 @@ cdef class SliceDecomposition(SageObject):
         cdef vector[vector[int]] lex_label
 
         # Compute the slice decomposition using the extended lexBFS algorithm
+        sig_on()
         extended_lex_BFS(cg, sigma, NULL, initial_v_int, NULL,
                          &(self.xslice_len), &lex_label)
+        sig_off()
 
         # Translate the results with the actual vertices of the graph
         self.sigma = tuple(Gbackend.vertex_label(v_int) for v_int in sigma)
-        self.sigma_inv = {v: i  for i, v in enumerate(self.sigma)}
-        self.lex_label = {i: tuple(Gbackend.vertex_label(v_int) for v_int in lli)
-                                    for i, lli in enumerate(lex_label)}
+        self.sigma_inv = {v: i for i, v in enumerate(self.sigma)}
+        self.lex_label = {i: tuple(Gbackend.vertex_label(v_int)
+                                   for v_int in lli)
+                          for i, lli in enumerate(lex_label)}
 
     def __eq__(self, other):
         """
@@ -480,7 +506,7 @@ cdef class SliceDecomposition(SageObject):
 
         OUTPUT:
 
-        A dictionnary with the keys:
+        A dictionary with the keys:
 
         * ``"pivot"`` -- the vertex `v` given as parameter
 
@@ -523,7 +549,7 @@ cdef class SliceDecomposition(SageObject):
              'sequence': [['u'], ['y', 'z']],
              'slice': ['u', 'y', 'z']}
 
-        Some values of the returned dictionnary can be obtained via other
+        Some values of the returned dictionary can be obtained via other
         methods (:meth:`~slice`, :meth:`~xslice_sequence`,
         :meth:`~active_edges`, :meth:`~lexicographic_label`)::
 

sage/graphs/graph_generators.py

@@ -36,11 +36,11 @@ def __append_to_doc(methods):
                 "    :widths: 33, 33, 33\n"
                 "    :delim: |\n\n")
 
-    h = (len(methods)+2)//3
+    h = (len(methods) + 2) // 3
     # Reorders the list of methods for horizontal reading, the only one Sphinx understands
-    reordered_methods = [0]*3*h
+    reordered_methods = [0] * (3 * h)
     for i, m in enumerate(methods):
-        reordered_methods[3*(i % h) + (i//h)] = m
+        reordered_methods[3 * (i % h) + (i // h)] = m
     methods = reordered_methods
 
     # Adding the list to the __doc__ string
@@ -845,7 +845,7 @@ class GraphGenerators:
             if vertices is None:
                 raise NotImplementedError
             if (len(degree_sequence) != vertices or sum(degree_sequence) % 2
-                    or sum(degree_sequence) > vertices*(vertices - 1)):
+                    or sum(degree_sequence) > vertices * (vertices - 1)):
                 raise ValueError("Invalid degree sequence.")
             degree_sequence = sorted(degree_sequence)
             if augment == 'edges':
@@ -1126,7 +1126,7 @@ class GraphGenerators:
 
         EXAMPLES:
 
-        The generator can be used to construct biparrtite graphs for testing,
+        The generator can be used to construct bipartite graphs for testing,
         one at a time (usually inside a loop).  Or it can be used to
         create an entire list all at once if there is sufficient memory
         to contain it::
@@ -1510,7 +1510,7 @@ class GraphGenerators:
     def _read_planar_code(self, code_input, immutable=False):
         r"""
         Return a generator for the plane graphs in planar code format in
-        the file code_input (see [BM2016]_).
+        the binary file ``code_input`` (see [BM2016]_).
 
         A file with planar code starts with a header ``>>planar_code<<``.
         After the header each graph is stored in the following way :
@@ -1524,7 +1524,7 @@ class GraphGenerators:
 
         INPUT:
 
-        - ``code_input`` -- a file containing valid planar code data
+        - ``code_input`` -- a binary file containing valid planar code data
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
           immutable or mutable graphs
@@ -1544,18 +1544,17 @@ class GraphGenerators:
 
         EXAMPLES:
 
-        The following example creates a small planar code file in memory and
-        reads it using the ``_read_planar_code`` method::
+        The following example creates a small planar code binary
+        file in memory and reads it using the ``_read_planar_code`` method::
 
-            sage: from io import StringIO
-            sage: code_input = StringIO('>>planar_code<<')
-            sage: _ = code_input.write('>>planar_code<<')
+            sage: from io import BytesIO
+            sage: code_input = BytesIO()
+            sage: n = code_input.write(b'>>planar_code<<')
             sage: for c in [4,2,3,4,0,1,4,3,0,1,2,4,0,1,3,2,0]:
-            ....:     _ = code_input.write('{:c}'.format(c))
-            sage: _ = code_input.seek(0)
+            ....:     n = code_input.write(bytes('{:c}'.format(c),'ascii'))
+            sage: n = code_input.seek(0)
             sage: gen = graphs._read_planar_code(code_input)
-            sage: l = list(gen)
-            sage: l
+            sage: l = list(gen); l
             [Graph on 4 vertices]
             sage: l[0].is_isomorphic(graphs.CompleteGraph(4))
             True
@@ -1564,10 +1563,33 @@ class GraphGenerators:
              2: [1, 4, 3],
              3: [1, 2, 4],
              4: [1, 3, 2]}
+
+        TESTS::
+
+            sage: from io import StringIO
+            sage: code_input = StringIO()
+            sage: n = code_input.write('>>planar_code<<')
+            sage: n = code_input.seek(0)
+            sage: list(graphs._read_planar_code(code_input))
+            Traceback (most recent call last):
+            ...
+            TypeError: not a binary file
+
+            sage: from io import BytesIO
+            sage: code_input = BytesIO()
+            sage: n = code_input.write(b'>>wrong header<<')
+            sage: n = code_input.seek(0)
+            sage: list(graphs._read_planar_code(code_input))
+            Traceback (most recent call last):
+            ...
+            TypeError: file has no valid planar code header
         """
         # start of code to read planar code
         header = code_input.read(15)
-        assert header == '>>planar_code<<', 'Not a valid planar code header'
+        if not isinstance(header, bytes):
+            raise TypeError('not a binary file')
+        if header != b'>>planar_code<<':
+            raise TypeError('file has no valid planar code header')
 
         # read graph per graph
         while True:
@@ -1720,10 +1742,7 @@ class GraphGenerators:
 
         sp = subprocess.Popen(command, shell=True,
                               stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE, close_fds=True,
-                              encoding='latin-1')
-
-        sp.stdout.reconfigure(newline='')
+                              stderr=subprocess.PIPE, close_fds=True)
 
         yield from graphs._read_planar_code(sp.stdout, immutable=immutable)
 
@@ -1811,10 +1830,7 @@ class GraphGenerators:
 
         sp = subprocess.Popen(command, shell=True,
                               stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE, close_fds=True,
-                              encoding='latin-1')
-
-        sp.stdout.reconfigure(newline='')
+                              stderr=subprocess.PIPE, close_fds=True)
 
         yield from graphs._read_planar_code(sp.stdout, immutable=immutable)
 
@@ -1999,14 +2015,11 @@ class GraphGenerators:
                                  options)
         sp = subprocess.Popen(command, shell=True,
                               stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE, close_fds=True,
-                              encoding='latin-1')
-
-        sp.stdout.reconfigure(newline='')
+                              stderr=subprocess.PIPE, close_fds=True)
 
         try:
             yield from graphs._read_planar_code(sp.stdout, immutable=immutable)
-        except AssertionError:
+        except (TypeError, AssertionError):
             raise AttributeError("invalid options '{}'".format(options))
 
     def planar_graphs(self, order, minimum_degree=None,
@@ -2209,7 +2222,7 @@ class GraphGenerators:
                     raise ValueError("the number of edges cannot be less than order - 1")
                 edges = '-e:{}'.format(maximum_edges)
         else:
-            if minimum_edges > 3*order - 6:
+            if minimum_edges > 3 * order - 6:
                 raise ValueError("the number of edges cannot be more than 3*order - 6")
             if maximum_edges is None:
                 edges = '-e{}:'.format(minimum_edges)
@@ -2970,7 +2983,7 @@ def canaug_traverse_vert(g, aut_gens, max_verts, property, dig=False, loops=Fals
         # in the case of graphs, there are n possibilities,
         # and in the case of digraphs, there are 2*n.
         if dig:
-            possibilities = 2*n
+            possibilities = 2 * n
         else:
             possibilities = n
         num_roots = 2**possibilities

sage/graphs/graph_generators_pyx.pyx

@@ -18,7 +18,8 @@ from sage.misc.randstate cimport random
 from sage.misc.randstate import set_random_seed
 
 
-def RandomGNP(n, p, bint directed=False, bint loops=False, seed=None):
+def RandomGNP(n, p, bint directed=False, bint loops=False, seed=None,
+              immutable=False):
     r"""
     Return a random graph or a digraph on `n` nodes.
 
@@ -39,6 +40,9 @@ def RandomGNP(n, p, bint directed=False, bint loops=False, seed=None):
     - ``seed`` -- a ``random.Random`` seed or a Python ``int`` for the random
       number generator (default: ``None``)
 
+    - ``immutable`` -- boolean (default: ``False``); whether to return an
+      immutable or mutable (di)graph.
+
     REFERENCES:
 
     - [ER1959]_
@@ -52,7 +56,8 @@ def RandomGNP(n, p, bint directed=False, bint loops=False, seed=None):
         sage: D.num_verts()
         10
         sage: D.edges(sort=True, labels=False)
-        [(0, 2), (0, 5), (1, 5), (1, 7), (4, 1), (4, 2), (4, 9), (5, 0), (5, 2), (5, 3), (5, 7), (6, 5), (7, 1), (8, 2), (8, 6), (9, 4)]
+        [(0, 3), (0, 6), (1, 7), (1, 9), (4, 6), (4, 7), (5, 4), (5, 6),
+         (5, 8), (5, 9), (6, 3), (7, 2), (7, 9), (8, 5), (9, 1), (9, 5)]
 
     TESTS::
 
@@ -73,23 +78,18 @@ def RandomGNP(n, p, bint directed=False, bint loops=False, seed=None):
     cdef int pp = int(round(float(p * RAND_MAX_f)))
 
     if directed:
-        from sage.graphs.digraph import DiGraph
-        G = DiGraph(loops=loops)
+        from sage.graphs.digraph import DiGraph as GT
     else:
-        from sage.graphs.graph import Graph
-        G = Graph()
         if loops:
             raise ValueError("parameter 'loops' can be set to True only when 'directed' is True")
-    G.name('Random' + ('Directed' if directed else '') + 'GNP(%s,%s)' % (n, p))
+        from sage.graphs.graph import Graph as GT
 
-    G.add_vertices(range(n))
+    name = 'Random' + ('Directed' if directed else '') + 'GNP(%s,%s)' % (n, p)
 
-    # Standard random GNP generator for Graph and DiGraph
     cdef int i, j
-    for i in range(n):
-        for j in range((0 if directed else i + 1), n):
-            if random() < pp:
-                if i != j or loops:
-                    G.add_edge(i, j)
+    edges = ((i, j) for i in range(n)
+                 for j in range((0 if directed else i + 1), n)
+                 if (i != j or loops) and random() < pp)
 
-    return G
+    return GT([range(n), edges], format='vertices_and_edges',
+              loops=directed and loops, name=name, immutable=immutable)

sage/graphs/graph_latex.py

@@ -430,7 +430,7 @@ Visit 'https://www.ctan.org/pkg/tkz-berge'.
 """)
 
 
-def have_tkz_graph():
+def have_tkz_graph() -> bool:
     r"""
     Return ``True`` if the proper LaTeX packages for the ``tikzpicture``
     environment are installed in the user's environment, namely ``tikz``,