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

sage/graphs/graph.py

@@ -105,7 +105,7 @@ covered here.
    ::
 
        sage: d = {0: [1,4,5], 1: [2,6], 2: [3,7], 3: [4,8], 4: [9], \
-             5: [7, 8], 6: [8,9], 7: [9]}
+       ....: 5: [7, 8], 6: [8,9], 7: [9]}
        sage: G = Graph(d); G
        Graph on 10 vertices
        sage: G.plot().show()    # or G.show()                                           # needs sage.plot
@@ -311,7 +311,7 @@ However, if one wants to define a dictionary, with the same keys and arbitrary
 objects for entries, one can make that association::
 
     sage: d = {0 : graphs.DodecahedralGraph(), 1 : graphs.FlowerSnark(), \
-          2 : graphs.MoebiusKantorGraph(), 3 : graphs.PetersenGraph() }
+    ....: 2 : graphs.MoebiusKantorGraph(), 3 : graphs.PetersenGraph() }
     sage: d[2]
     Moebius-Kantor Graph: Graph on 16 vertices
     sage: T = graphs.TetrahedralGraph()
@@ -379,7 +379,7 @@ suitable for inclusion in a `\LaTeX` document.  More details on this are at the
 
     sage: from sage.graphs.graph_latex import check_tkz_graph
     sage: check_tkz_graph()  # random - depends on TeX installation
-    sage: latex(G)
+    sage: latex(G)                                                                      # needs sage.plot
     \begin{tikzpicture}
     ...
     \end{tikzpicture}
@@ -5276,42 +5276,12 @@ class Graph(GenericGraph):
             sage: D.get_vertices()
             {0: 'foo', 1: None, 2: None}
         """
-        if sparse is not None:
-            if data_structure is not None:
-                raise ValueError("The 'sparse' argument is an alias for "
-                                 "'data_structure'. Please do not define both.")
-            data_structure = "sparse" if sparse else "dense"
-
-        if data_structure is None:
-            from sage.graphs.base.dense_graph import DenseGraphBackend
-            from sage.graphs.base.sparse_graph import SparseGraphBackend
-            if isinstance(self._backend, DenseGraphBackend):
-                data_structure = "dense"
-            elif isinstance(self._backend, SparseGraphBackend):
-                data_structure = "sparse"
-            else:
-                data_structure = "static_sparse"
-        from sage.graphs.digraph import DiGraph
-        D = DiGraph(name=self.name(),
-                    pos=self.get_pos(),
-                    multiedges=self.allows_multiple_edges(),
-                    loops=self.allows_loops(),
-                    data_structure=(data_structure if data_structure != "static_sparse"
-                                    else "sparse"))  # we need a mutable copy
-
-        D.add_vertices(self.vertex_iterator())
-        D.set_vertices(self.get_vertices())
-        for u, v, l in self.edge_iterator():
-            D.add_edge(u, v, l)
-            D.add_edge(v, u, l)
-        if hasattr(self, '_embedding'):
-            D._embedding = copy(self._embedding)
-        D._weighted = self._weighted
-
-        if data_structure == "static_sparse":
-            D = D.copy(data_structure=data_structure)
-
-        return D
+        from sage.graphs.orientations import _initialize_digraph
+        from itertools import chain
+        edges = chain(self.edge_iterator(),
+                      ((v, u, l) for u, v, l in self.edge_iterator()))
+        return _initialize_digraph(self, edges, name=self.name(),
+                                   data_structure=data_structure, sparse=sparse)
 
     @doc_index("Basic methods")
     def to_undirected(self):
@@ -5535,7 +5505,7 @@ class Graph(GenericGraph):
         # Triangles
         K3 = Graph({1: [2, 3], 2: [3]}, format='dict_of_lists')
         for x, y, z in G.subgraph_search_iterator(K3, return_graphs=False):
-            if x < y and y < z:
+            if x < y < z:
                 T.append([x, y, z])
 
         # Triples with just one edge
@@ -5828,12 +5798,6 @@ class Graph(GenericGraph):
           implementation of the Bron and Kerbosch Algorithm [BK1973]_
 
 
-        .. NOTE::
-
-            This method sorts its output before returning it. If you prefer to
-            save the extra time, you can call
-            :class:`sage.graphs.independent_sets.IndependentSets` directly.
-
         .. NOTE::
 
             Sage's implementation of the enumeration of *maximal* independent
@@ -9311,6 +9275,7 @@ class Graph(GenericGraph):
     from sage.graphs.orientations import eulerian_orientation
     from sage.graphs.connectivity import bridges, cleave, spqr_tree
     from sage.graphs.connectivity import is_triconnected
+    from sage.graphs.connectivity import minimal_separators
     from sage.graphs.comparability import is_comparability
     from sage.graphs.comparability import is_permutation
     geodetic_closure = LazyImport('sage.graphs.convexity_properties', 'geodetic_closure', at_startup=True)
@@ -9371,6 +9336,7 @@ _additional_categories = {
     "cleave"                    : "Connectivity, orientations, trees",
     "spqr_tree"                 : "Connectivity, orientations, trees",
     "is_triconnected"           : "Connectivity, orientations, trees",
+    "minimal_separators"        : "Connectivity, orientations, trees",
     "is_dominating"             : "Domination",
     "is_redundant"              : "Domination",
     "private_neighbors"         : "Domination",

sage/graphs/graph_database.py

@@ -430,7 +430,7 @@ class GraphQuery(GenericGraphQuery):
             SQLQuery.__init__(self, graph_db)
 
             # if display_cols is None:
-            #    raise TypeError, 'Nonetype display_cols cannot retrieve data.'
+            #     raise TypeError('Nonetype display_cols cannot retrieve data')
 
             master_join = {}
 

sage/graphs/graph_generators.py

@@ -487,9 +487,6 @@ Functions and methods
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-# import from Python standard library
-
-# import from Sage library
 from . import graph
 
 
@@ -574,14 +571,19 @@ class GraphGenerators:
     - ``sparse`` -- (default: ``True``) whether to use a sparse or dense data
       structure. See the documentation of :class:`~sage.graphs.graph.Graph`.
 
-    - ``copy`` -- boolean; if set to ``True`` (default)
-      this method makes copies of the graphs before returning
-      them. If set to ``False`` the method returns the graph it
-      is working on. The second alternative is faster, but modifying
-      any of the graph instances returned by the method may break
-      the function's behaviour, as it is using these graphs to
-      compute the next ones: only use ``copy = False`` when
-      you stick to *reading* the graphs returned.
+    - ``copy`` -- boolean (default: ``True``); whether to return copies. If set
+      to ``False`` the method returns the graph it is working on. The second
+      alternative is faster, but modifying any of the graph instances returned
+      by the method may break the function's behaviour, as it is using these
+      graphs to compute the next ones: only use ``copy=False`` when you stick
+      to *reading* the graphs returned.
+
+      This parameter is ignored when ``immutable`` is set to ``True``, in which
+      case returned graphs are always copies.
+
+    - ``immutable`` -- boolean (default: ``False``); whether to return immutable
+      or mutable graphs. When set to ``True``, this parameter implies
+      ``copy=True``.
 
     EXAMPLES:
 
@@ -751,6 +753,24 @@ class GraphGenerators:
         2
         2
 
+    Returned graphs can be mutable or immutable::
+
+        sage: # needs nauty
+        sage: G = next(graphs(3, immutable=False))
+        sage: G.delete_vertex(0)
+        sage: G = next(graphs(3, immutable=True))
+        sage: G.delete_vertex(0)
+        Traceback (most recent call last):
+        ...
+        ValueError: graph is immutable; please change a copy instead (use function copy())
+        sage: G = next(graphs(4, degree_sequence=[3]*4))
+        sage: G.delete_vertex(0)
+        sage: G = next(graphs(4, degree_sequence=[3]*4, immutable=True))
+        sage: G.delete_vertex(0)
+        Traceback (most recent call last):
+        ...
+        ValueError: graph is immutable; please change a copy instead (use function copy())
+
     REFERENCE:
 
     - Brendan D. McKay, Isomorph-Free Exhaustive generation.  *Journal
@@ -762,7 +782,8 @@ class GraphGenerators:
 ###########################################################################
 
     def __call__(self, vertices=None, property=None, augment='edges', size=None,
-                 degree_sequence=None, loops=False, sparse=True, copy=True):
+                 degree_sequence=None, loops=False, sparse=True, copy=True,
+                 immutable=False):
         """
         Access the generator of isomorphism class representatives.
         Iterates over distinct, exhaustive representatives. See the docstring
@@ -812,18 +833,14 @@ class GraphGenerators:
         # Use nauty for the basic case, as it is much faster.
         if (vertices and property is None and size is None and
                 degree_sequence is None and not loops and augment == 'edges' and
-                sparse and copy):
-            for g in graphs.nauty_geng(vertices):
-                yield g
+                sparse and (copy or immutable)):
+            yield from graphs.nauty_geng(vertices, immutable=immutable)
             return
 
         if property is None:
             def property(x):
                 return True
 
-        from sage.graphs.graph import Graph
-        from copy import copy as copyfun
-
         if degree_sequence is not None:
             if vertices is None:
                 raise NotImplementedError
@@ -857,19 +874,19 @@ class GraphGenerators:
         if augment == 'vertices':
             if vertices is None:
                 raise NotImplementedError
-            g = Graph(loops=loops, sparse=sparse)
+            g = graph.Graph(loops=loops, sparse=sparse)
             for gg in canaug_traverse_vert(g, [], vertices, property, loops=loops, sparse=sparse):
                 if extra_property(gg):
-                    yield copyfun(gg) if copy else gg
+                    yield gg.copy(immutable=immutable) if copy or immutable else gg
         elif augment == 'edges':
             if vertices is None:
                 from sage.rings.integer import Integer
                 vertices = Integer(0)
                 while True:
                     for g in self(vertices, loops=loops, sparse=sparse):
-                        yield copyfun(g) if copy else g
+                        yield g.copy(immutable=immutable) if copy or immutable else g
                     vertices += 1
-            g = Graph(vertices, loops=loops, sparse=sparse)
+            g = graph.Graph(vertices, loops=loops, sparse=sparse)
             gens = []
             for i in range(vertices - 1):
                 gen = list(range(i))
@@ -879,11 +896,11 @@ class GraphGenerators:
                 gens.append(gen)
             for gg in canaug_traverse_edge(g, gens, property, loops=loops, sparse=sparse):
                 if extra_property(gg):
-                    yield copyfun(gg) if copy else gg
+                    yield gg.copy(immutable=immutable) if copy or immutable else gg
         else:
             raise NotImplementedError
 
-    def nauty_geng(self, options='', debug=False):
+    def nauty_geng(self, options='', debug=False, immutable=False):
         r"""
         Return a generator which creates graphs from nauty's geng program.
 
@@ -902,6 +919,9 @@ class GraphGenerators:
           the program with some information on the arguments, while a line
           beginning with ">E" indicates an error with the input.
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         The possible options, obtained as output of ``geng --help``::
 
                  n       : the number of vertices
@@ -1029,10 +1049,9 @@ class GraphGenerators:
             except StopIteration:
                 # Exhausted list of graphs from nauty geng
                 return
-            G = graph.Graph(s[:-1], format='graph6')
-            yield G
+            yield graph.Graph(s[:-1], format='graph6', immutable=immutable)
 
-    def nauty_genbg(self, options='', debug=False):
+    def nauty_genbg(self, options='', debug=False, immutable=False):
         r"""
         Return a generator which creates bipartite graphs from nauty's ``genbgL``
         program.
@@ -1052,6 +1071,9 @@ class GraphGenerators:
           the program with some information on the arguments, while a line
           beginning with ">E" indicates an error with the input.
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         The possible options, obtained as output of ``genbgL --help``::
 
                 n1       : the number of vertices in the first class.
@@ -1237,10 +1259,10 @@ class GraphGenerators:
             except StopIteration:
                 # Exhausted list of bipartite graphs from nauty genbgL
                 return
-            G = BipartiteGraph(s[:-1], format='graph6', partition=partition)
-            yield G
+            yield BipartiteGraph(s[:-1], format='graph6', partition=partition,
+                                 immutable=immutable)
 
-    def nauty_genktreeg(self, options='', debug=False):
+    def nauty_genktreeg(self, options='', debug=False, immutable=False):
         r"""
         Return a generator which creates all `k`-trees using nauty..
 
@@ -1265,6 +1287,9 @@ class GraphGenerators:
           the program with some information on the arguments, while a line
           beginning with ">E" indicates an error with the input.
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         The possible options, obtained as output of ``genktreeg --help``::
 
                  n       : the number of vertices
@@ -1352,10 +1377,10 @@ class GraphGenerators:
             except StopIteration:
                 # Exhausted list of graphs from nauty geng
                 return
-            G = graph.Graph(s[:-1], format='graph6')
-            yield G
+            yield graph.Graph(s[:-1], format='graph6', immutable=immutable)
 
-    def cospectral_graphs(self, vertices, matrix_function=None, graphs=None):
+    def cospectral_graphs(self, vertices, matrix_function=None, graphs=None,
+                          immutable=False):
         r"""
         Find all sets of graphs on ``vertices`` vertices (with
         possible restrictions) which are cospectral with respect to a
@@ -1382,6 +1407,9 @@ class GraphGenerators:
              are tested for cospectral sets.  In this case,
              ``vertices`` is ignored.
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         OUTPUT:
 
            A list of lists of graphs.  Each sublist will be a list of
@@ -1454,11 +1482,15 @@ class GraphGenerators:
         if matrix_function is None:
             matrix_function = lambda g: g.adjacency_matrix()
 
+        def prop(x):
+            return True
+
         from sage.graphs.graph_generators import graphs as graph_gen
         if graphs is None:
-            graph_list = graph_gen(vertices, property=lambda _: True)
+            graph_list = graph_gen(vertices, property=prop, immutable=immutable)
         elif callable(graphs):
-            graph_list = iter(g for g in graph_gen(vertices, property=lambda _: True) if graphs(g))
+            graph_list = (g for g in graph_gen(vertices, property=prop,
+                                               immutable=immutable) if graphs(g))
         else:
             graph_list = iter(graphs)
 
@@ -1475,7 +1507,7 @@ class GraphGenerators:
 
         return cospectral_graphs
 
-    def _read_planar_code(self, code_input):
+    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]_).
@@ -1494,6 +1526,9 @@ class GraphGenerators:
 
         - ``code_input`` -- a file containing valid planar code data
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         OUTPUT:
 
         A generator which will produce the plane graphs as Sage graphs
@@ -1575,14 +1610,14 @@ class GraphGenerators:
                 if Ni > 1:
                     edges_g[i + 1] += [i + 1] * (Ni // 2)
                     has_loops = True
-            G = graph.Graph(edges_g, loops=has_loops)
+            G = graph.Graph(edges_g, loops=has_loops, immutable=immutable)
 
             if not (G.has_multiple_edges() or has_loops):
                 embed_g = {i + 1: di for i, di in enumerate(g)}
                 G.set_embedding(embed_g)
             yield G
 
-    def fullerenes(self, order, ipr=False):
+    def fullerenes(self, order, ipr=False, immutable=False):
         r"""
         Return a generator which creates fullerene graphs using
         the buckygen generator (see [BGM2012]_).
@@ -1592,10 +1627,13 @@ class GraphGenerators:
         - ``order`` -- a positive even integer smaller than or equal to 254
           This specifies the number of vertices in the generated fullerenes
 
-        - ``ipr`` -- (default: ``False``) if ``True`` only fullerenes that
-          satisfy the Isolated Pentagon Rule are generated. This means that
+        - ``ipr`` -- boolean (default: ``False``); if ``True`` only fullerenes
+          that satisfy the Isolated Pentagon Rule are generated. This means that
           no pentagonal faces share an edge.
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         OUTPUT:
 
         A generator which will produce the fullerene graphs as Sage graphs
@@ -1687,9 +1725,9 @@ class GraphGenerators:
 
         sp.stdout.reconfigure(newline='')
 
-        yield from graphs._read_planar_code(sp.stdout)
+        yield from graphs._read_planar_code(sp.stdout, immutable=immutable)
 
-    def fusenes(self, hexagon_count, benzenoids=False):
+    def fusenes(self, hexagon_count, benzenoids=False, immutable=False):
         r"""
         Return a generator which creates fusenes and benzenoids using
         the benzene generator (see [BCH2002]_). Fusenes are planar
@@ -1701,8 +1739,11 @@ class GraphGenerators:
         - ``hexagon_count`` -- positive integer smaller than or equal to 30;
           this specifies the number of hexagons in the generated benzenoids
 
-        - ``benzenoids`` -- (default: ``False``) if ``True`` only benzenoids are
-          generated
+        - ``benzenoids`` -- boolean (default: ``False``); if ``True`` only
+          benzenoids are generated
+
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
 
         OUTPUT:
 
@@ -1775,10 +1816,9 @@ class GraphGenerators:
 
         sp.stdout.reconfigure(newline='')
 
-        for G in graphs._read_planar_code(sp.stdout):
-            yield G
+        yield from graphs._read_planar_code(sp.stdout, immutable=immutable)
 
-    def plantri_gen(self, options=""):
+    def plantri_gen(self, options="", immutable=False):
         r"""
         Iterator over planar graphs created using the ``plantri`` generator.
 
@@ -1801,6 +1841,9 @@ class GraphGenerators:
           output of plantri to be in "planar code" format, so do not set an
           option to change this default or results will be unpredictable.
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         The possible options are::
 
             n       : the number of vertices (the only compulsory parameter).
@@ -1962,7 +2005,7 @@ class GraphGenerators:
         sp.stdout.reconfigure(newline='')
 
         try:
-            yield from graphs._read_planar_code(sp.stdout)
+            yield from graphs._read_planar_code(sp.stdout, immutable=immutable)
         except AssertionError:
             raise AttributeError("invalid options '{}'".format(options))
 
@@ -1973,7 +2016,8 @@ class GraphGenerators:
                       maximum_edges=None,
                       maximum_face_size=None,
                       only_bipartite=False,
-                      dual=False):
+                      dual=False,
+                      immutable=False):
         r"""
         An iterator over connected planar graphs using the plantri generator.
 
@@ -2025,6 +2069,9 @@ class GraphGenerators:
         - ``dual`` -- (default: ``False``) if ``True`` return instead the
           planar duals of the generated graphs
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         OUTPUT:
 
         An iterator which will produce all planar graphs with the given
@@ -2190,7 +2237,7 @@ class GraphGenerators:
 
         if order == 1:
             if minimum_degree == 0:
-                G = graph.Graph(1)
+                G = graph.Graph(1, immutable=immutable)
                 G.set_embedding({0: []})
                 yield G
             return
@@ -2204,10 +2251,11 @@ class GraphGenerators:
                              edges, faces,
                              order)
 
-        yield from graphs.plantri_gen(command)
+        yield from graphs.plantri_gen(command, immutable=immutable)
 
     def triangulations(self, order, minimum_degree=None, minimum_connectivity=None,
-                       exact_connectivity=False, only_eulerian=False, dual=False):
+                       exact_connectivity=False, only_eulerian=False, dual=False,
+                       immutable=False):
         r"""
         An iterator over connected planar triangulations using the plantri generator.
 
@@ -2245,6 +2293,9 @@ class GraphGenerators:
         - ``dual`` -- (default: ``False``) if ``True`` return instead the
           planar duals of the generated graphs
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         OUTPUT:
 
         An iterator which will produce all planar triangulations with the given
@@ -2390,10 +2441,11 @@ class GraphGenerators:
                              'd' if dual else '',
                              order)
 
-        yield from graphs.plantri_gen(command)
+        yield from graphs.plantri_gen(command, immutable=immutable)
 
     def quadrangulations(self, order, minimum_degree=None, minimum_connectivity=None,
-                         no_nonfacial_quadrangles=False, dual=False):
+                         no_nonfacial_quadrangles=False, dual=False,
+                         immutable=False):
         r"""
         An iterator over planar quadrangulations using the plantri generator.
 
@@ -2427,6 +2479,9 @@ class GraphGenerators:
         - ``dual`` -- (default: ``False``) if ``True`` return instead the
           planar duals of the generated graphs
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         OUTPUT:
 
         An iterator which will produce all planar quadrangulations with the given
@@ -2525,7 +2580,7 @@ class GraphGenerators:
                              'd' if dual else '',
                              order)
 
-        yield from graphs.plantri_gen(command)
+        yield from graphs.plantri_gen(command, immutable=immutable)
 
 ###########################################################################
 # Basic Graphs

sage/graphs/graph_latex.py

@@ -1202,7 +1202,7 @@ class GraphLatex(SageObject):
                     raise TypeError('%s option must be a dictionary, not %s' % (name, value))
                 else:
                     for key, p in value.items():
-                        if not (type(p) in [float, RealLiteral] and (0 <= p) and (p <= 1)) and (p not in label_places):
+                        if not (isinstance(p, (float, RealLiteral)) and (0 <= p <= 1)) and (p not in label_places):
                             raise ValueError('%s option for %s needs to be a number between 0.0 and 1.0 or a place (like "above"), not %s' % (name, key, p))
             elif name == 'loop_placements':
                 if not isinstance(value, dict):

sage/graphs/graph_list.py

@@ -19,9 +19,6 @@ AUTHORS:
 # ****************************************************************************
 
 
-from sage.misc.misc import try_read
-
-
 def from_whatever(data):
     r"""
     Return a list of Sage Graphs, given a list of whatever kind of data.
@@ -78,6 +75,8 @@ def _from_whatever(data, fmt=None):
     if isinstance(data, str):
         lines = data.splitlines()
     else:
+        from sage.misc.misc import try_read
+
         lines = try_read(data, splitlines=True)
 
         if lines is not None and fmt is None: