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

sage/graphs/generic_graph_pyx.pyx

@@ -33,6 +33,8 @@ from memory_allocator cimport MemoryAllocator
 from sage.cpython.string cimport char_to_str
 from sage.libs.gmp.mpz cimport *
 from sage.misc.prandom import random
+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 init_reverse
@@ -1328,6 +1330,18 @@ cpdef tuple find_hamiltonian(G, long max_iter=100000, long reset_bound=30000,
         sage: b, C = fh(G, find_path=False)
         sage: b, len(C)
         (True, 4)
+
+    Immutable graphs::
+
+        sage: G = graphs.PetersenGraph()
+        sage: H = Graph(G, immutable=True)
+        sage: fh(H)
+        (False, [7, 5, 0, 1, 2, 3, 8, 6, 9, 4])
+        sage: fh(H, find_path=True)
+        (True, [5, 0, 1, 6, 8, 3, 2, 7, 9, 4])
+        sage: G = DiGraph([(0, 1), (1, 2), (2, 3)], immutable=True)
+        sage: fh(G)
+        (False, [0, 1, 2, 3])
     """
     G._scream_if_not_simple()
 
@@ -1373,13 +1387,23 @@ cpdef tuple find_hamiltonian(G, long max_iter=100000, long reset_bound=30000,
     memset(member, 0, n * sizeof(int))
 
     # static copy of the graph for more efficient operations
-    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 short_digraph rev_sd
     cdef bint reverse = False
     if directed:
-        init_reverse(rev_sd, sd)
+        if isinstance(G, StaticSparseBackend) and cg._directed:
+            rev_sd = <short_digraph> cg.g_rev
+        else:
+            init_reverse(rev_sd, sd)
 
     # A list to store the available vertices at each step
     cdef list available_vertices = []
@@ -1519,9 +1543,11 @@ cpdef tuple find_hamiltonian(G, long max_iter=100000, long reset_bound=30000,
 
         if bigcount * reset_bound > max_iter:
             output = [int_to_vertex[longest_path[i]] for i in range(longest)]
-            free_short_digraph(sd)
+            if not isinstance(G, StaticSparseBackend):
+                free_short_digraph(sd)
             if directed:
-                free_short_digraph(rev_sd)
+                if not (isinstance(G, StaticSparseBackend) and cg._directed):
+                    free_short_digraph(rev_sd)
                 if longest_reversed:
                     return (False, output[::-1])
             return (False, output)
@@ -1552,14 +1578,15 @@ cpdef tuple find_hamiltonian(G, long max_iter=100000, long reset_bound=30000,
                            f"{int_to_vertex[path[0]]} are not adjacent")
 
     output = [int_to_vertex[path[i]] for i in range(length)]
-    free_short_digraph(sd)
-    if directed:
+    if not isinstance(G, StaticSparseBackend):
+        free_short_digraph(sd)
+    if directed and not (isinstance(G, StaticSparseBackend) and cg._directed):
         free_short_digraph(rev_sd)
 
     return (True, output)
 
 
-def transitive_reduction_acyclic(G):
+def transitive_reduction_acyclic(G, immutable=None):
     r"""
     Return the transitive reduction of an acyclic digraph.
 
@@ -1567,12 +1594,29 @@ def transitive_reduction_acyclic(G):
 
     - ``G`` -- an acyclic digraph
 
+    - ``immutable`` -- boolean (default: ``None``); whether to create a
+      mutable/immutable transitive closure. ``immutable=None`` (default) means
+      that the (di)graph and its transitive closure will behave the same way.
+
     EXAMPLES::
 
         sage: from sage.graphs.generic_graph_pyx import transitive_reduction_acyclic
         sage: G = posets.BooleanLattice(4).hasse_diagram()
         sage: G == transitive_reduction_acyclic(G.transitive_closure())
         True
+
+    TESTS:
+
+    Check the behavior of parameter ``immutable``::
+
+        sage: G = DiGraph([(0, 1)])
+        sage: transitive_reduction_acyclic(G).is_immutable()
+        False
+        sage: transitive_reduction_acyclic(G, immutable=True).is_immutable()
+        True
+        sage: G = DiGraph([(0, 1)], immutable=True)
+        sage: transitive_reduction_acyclic(G).is_immutable()
+        True
     """
     cdef int  n = G.order()
     cdef dict v_to_int = {vv: i for i, vv in enumerate(G)}
@@ -1616,10 +1660,13 @@ def transitive_reduction_acyclic(G):
             if binary_matrix_get(closure, u, v):
                 useful_edges.append((uu, vv))
 
+    if immutable is None:
+        immutable = G.is_immutable()
+
     from sage.graphs.digraph import DiGraph
-    reduced = DiGraph()
-    reduced.add_edges(useful_edges)
-    reduced.add_vertices(linear_extension)
+    reduced = DiGraph([linear_extension, useful_edges],
+                      format='vertices_and_edges',
+                      immutable=immutable)
 
     binary_matrix_free(closure)
 

sage/graphs/genus.pyx

@@ -147,7 +147,7 @@ cdef class simple_connected_genus_backtracker:
 
         for v in range(self.num_verts):
             if not G.has_vertex(v):
-                raise ValueError("Please relabel G so vertices are 0, ..., n-1")
+                raise ValueError("please relabel G so vertices are 0, ..., n-1")
 
             dv = G.in_degrees[v]
             self.degree[v] = 0
@@ -207,7 +207,6 @@ cdef class simple_connected_genus_backtracker:
         Quickly store the current face_map so we can recover
         the embedding it corresponds to later.
         """
-
         memcpy(self.face_freeze, self.face_map, self.num_darts * sizeof(int))
 
     def get_embedding(self):
@@ -586,7 +585,7 @@ def simple_connected_graph_genus(G, set_embedding=False, check=True, minimal=Tru
 
     REFERENCES:
 
-    [1] http://www.springerlink.com/content/0776127h0r7548v7/
+    [1] :doi:`10.1007/s00373-007-0729-9`
     """
     cdef int style, cutoff
     oG = G  # original graph
@@ -596,7 +595,7 @@ def simple_connected_graph_genus(G, set_embedding=False, check=True, minimal=Tru
 
     if check:
         if not G.is_connected():
-            raise ValueError("Cannot compute the genus of a disconnected graph")
+            raise ValueError("cannot compute the genus of a disconnected graph")
 
         if G.is_directed() or G.has_multiple_edges() or G.has_loops():
             G = G.to_simple()

sage/graphs/graph.py

@@ -2923,6 +2923,252 @@ class Graph(GenericGraph):
                 return False
         return deg_one_counter == 2 and seen_counter == order
 
+    @doc_index("Graph properties")
+    def is_chordal_bipartite(self, certificate=False):
+        r"""
+        Check whether the given graph is chordal bipartite.
+
+        A graph `G` is chordal bipartite if it is bipartite and has no induced
+        cycle of length at least 6.
+
+        An edge `(x, y) \in E` is bisimplical if `N(x) \cup N(y)` induces a
+        complete bipartite subgraph of `G`.
+
+        A Perfect Edge Without Vertex Elimination Ordering of a bipartite graph
+        `G = (X, Y, E)` is an ordering `e_1,...,e_m` of its edge set such that
+        for all `1 \leq i \leq m`, `e_i` is a bisimplical edge of
+        `G_i = (X, Y, E_i)` where `E_i` consists of the edges `e_i,e_{i+1}...,e_m`.
+
+        A graph `G` is chordal bipartite if and only if it has a Perfect Edge
+        Without Vertex Elimination Ordering. See Lemma 4 in [KKD1995]_.
+
+        INPUT:
+
+        - ``certificate`` -- boolean (default: ``False``); whether to return a
+          certificate
+
+        OUTPUT:
+
+        When ``certificate`` is set to ``False`` (default) this method only
+        returns ``True`` or ``False`` answers. When ``certificate`` is set to
+        ``True``, the method either returns:
+
+        * ``(True, pewveo)`` when the graph is chordal bipartite, where ``pewveo``
+          is a Perfect Edge Without Vertex Elimination Ordering of edges.
+
+        * ``(False, cycle)`` when the graph is not chordal bipartite, where
+          ``cycle`` is an odd cycle or a chordless cycle of length at least 6.
+
+        ALGORITHM:
+
+        This algorithm is based on these facts. The first one is trivial.
+
+        * A reduced adjacnecy matrix
+          (:meth:`~sage.graphs.bipartite_graph.BipartiteGraph.reduced_adjacency_matrix`)
+          of a bipartite graph has no cycle submatrix if and only if the graph is
+          chordal bipartite, where cycle submatrix is 0-1 `n \times n` matrix `n \geq 3`
+          with exactly two 1's in each row and column and no proper submatrix satsify
+          this property.
+
+        * A doubly lexical ordering
+          (:meth:`~sage.matrix.matrix_mod2_dense.Matrix_mod2_dense.doubly_lexical_ordering`)
+          of a 0-1 matrix is `\Gamma`-free
+          (:meth:`~sage.matrix.matrix_mod2_dense.Matrix_mod2_dense.is_Gamma_free`) if and
+          only if the matrix has no cycle submatrix. See Theorem 5.4 in [Lub1987]_.
+
+        Hence, checking a doubly lexical ordering of a reduced adjacency matrix
+        of a bipartite graph is `\Gamma`-free leads to detecting the graph
+        is chordal bipartite. Also, this matrix contains a certificate. Hence,
+        if `G` is chordal bipartite, we find a Perfect Edge Without Vertex
+        Elimination Ordering of edges by Lemma 10 in [KKD1995]_.
+        Otherwise, we can find a cycle submatrix by Theorem 5.2 in [Lub1987]_.
+        The time complexity of this algorithm is `O(n^3)`.
+
+        EXAMPLES:
+
+        A non-bipartite graph is not chordal bipartite::
+
+            sage: g = graphs.CycleGraph(5)
+            sage: g.is_chordal_bipartite()
+            False
+            sage: _, cycle = g.is_chordal_bipartite(certificate=True)
+            sage: len(cycle) % 2 == 1
+            True
+
+        A 6-cycle graph is not chordal bipartite::
+
+            sage: # needs sage.modules
+            sage: g = graphs.CycleGraph(6)
+            sage: g.is_chordal_bipartite()
+            False
+            sage: _, cycle = g.is_chordal_bipartite(certificate=True)
+            sage: len(cycle) == 6
+            True
+
+        A `2 \times n` grid graph is chordal bipartite::
+
+            sage: # needs sage.modules
+            sage: g = graphs.Grid2dGraph(2, 6)
+            sage: result, pewveo = g.is_chordal_bipartite(certificate=True)
+            sage: result
+            True
+
+        Let us check the certificate given by Sage is indeed a perfect
+        edge without vertex elimination ordering::
+
+            sage: # needs sage.modules
+            sage: for e in pewveo:
+            ....:     a = g.subgraph(vertices=g.neighbors(e[0]) + g.neighbors(e[1]))
+            ....:     b = BipartiteGraph(a).complement_bipartite()
+            ....:     if b.edges():
+            ....:          raise ValueError("this should never happen")
+            ....:     g.delete_edge(e)
+
+        Let us check the certificate given by Sage is indeed a
+        chordless cycle of length at least 6::
+
+            sage: # needs sage.modules
+            sage: g = graphs.Grid2dGraph(3, 6)
+            sage: result, cycle = g.is_chordal_bipartite(certificate=True)
+            sage: result
+            False
+            sage: l = len(cycle); l >= 6
+            True
+            sage: for i in range(len(cycle)):
+            ....:     if not g.has_edge(cycle[i], cycle[(i+1)%l]):
+            ....:         raise ValueError("this should never happen")
+            sage: h = g.subgraph(vertices=cycle)
+            sage: h.is_cycle()
+            True
+
+        TESTS:
+
+        The algorithm works correctly for disconnected graphs::
+
+            sage: # needs sage.modules
+            sage: c4 = graphs.CycleGraph(4)
+            sage: g = c4.disjoint_union(graphs.CycleGraph(6))
+            sage: g.is_chordal_bipartite()
+            False
+            sage: _, cycle = g.is_chordal_bipartite(certificate=True)
+            sage: len(cycle) == 6
+            True
+            sage: g = c4.disjoint_union(graphs.Grid2dGraph(2, 6))
+            sage: g.is_chordal_bipartite()
+            True
+            sage: _, pewveo = g.is_chordal_bipartite(certificate=True)
+            sage: for e in pewveo:
+            ....:     a = g.subgraph(vertices=g.neighbors(e[0]) + g.neighbors(e[1]))
+            ....:     b = BipartiteGraph(a).complement_bipartite()
+            ....:     if b.edges():
+            ....:          raise ValueError("this should never happen")
+            ....:     g.delete_edge(e)
+        """
+        self._scream_if_not_simple()
+        is_bipartite, bipartite_certificate = self.is_bipartite(certificate=True)
+        if not is_bipartite:
+            return False if not certificate else (False, bipartite_certificate)
+
+        # If the graph is not connected, we are computing the result on each
+        # component
+        if not self.is_connected():
+            # If the user wants a certificate, we had no choice but to collect
+            # the Perfect Edge Without Vertex Elimination Ordering. But we
+            # return a cycle certificate immediately if we find any.
+            if certificate:
+                pewveo = []
+                for gg in self.connected_components_subgraphs():
+                    b, certif = gg.is_chordal_bipartite(certificate=True)
+                    if not b:
+                        return False, certif
+                    pewveo.extend(certif)
+                return True, pewveo
+            return all(gg.is_chordal_bipartite() for gg in
+                        self.connected_components_subgraphs())
+
+        left = [v for v, c in bipartite_certificate.items() if c == 0]
+        right = [v for v, c in bipartite_certificate.items() if c == 1]
+        order_left = len(left)
+        order_right = len(right)
+
+        # We set |left| > |right| for optimization, i.e. time complexity of
+        # doubly lexical ordering algorithm is O(nm^2) for a n x m matrix.
+        if order_left < order_right:
+            left, right = right, left
+            order_left, order_right = order_right, order_left
+
+        # create a reduced_adjacency_matrix
+        from sage.rings.finite_rings.finite_field_prime_modn import FiniteField_prime_modn
+        A = self.adjacency_matrix(vertices=left+right, base_ring=FiniteField_prime_modn(2))
+        B = A[range(order_left), range(order_left, order_left + order_right)]
+
+        # get doubly lexical ordering of reduced_adjacency_matrix
+        row_ordering, col_ordering = B.doubly_lexical_ordering(inplace=True)
+
+        # determine if B is Gamma-free or not
+        is_Gamma_free, Gamma_submatrix_indices = B.is_Gamma_free(certificate=True)
+
+        if not certificate:
+            return is_Gamma_free
+
+        row_ordering_dict = {k-1: v-1 for k, v in row_ordering.dict().items()}
+        col_ordering_dict = {k-1: v-1 for k, v in col_ordering.dict().items()}
+        row_vertices = [left[row_ordering_dict[i]] for i in range(order_left)]
+        col_vertices = [right[col_ordering_dict[i]] for i in range(order_right)]
+
+        if is_Gamma_free:
+            pewveo = dict()
+            order = 0
+            for i, vi in enumerate(row_vertices):
+                for j, vj in enumerate(col_vertices):
+                    if B[i, j] == 1:
+                        pewveo[vi, vj] = order
+                        pewveo[vj, vi] = order
+                        order += 1
+            edges = self.edges(sort=True, key=lambda x: pewveo[x[0], x[1]])
+            return True, edges
+
+        # Find a chordless cycle of length at least 6
+        r1, c1, r2, c2 = Gamma_submatrix_indices
+        row_indices = [r1, r2]
+        col_indices = [c1, c2]
+        while not B[row_indices[-1], col_indices[-1]]:
+            # find the rightmost column with different value
+            # in row_indices[-2] and row_indices[-1]
+            col = order_right - 1
+            while col > col_indices[-1]:
+                if not B[row_indices[-2], col] and B[row_indices[-1], col]:
+                    break
+                col -= 1
+            assert col > col_indices[-1]
+
+            # find the bottommost row with different value
+            # in col_indices[-2] and col_indices[-1]
+            row = order_left - 1
+            while row > row_indices[-1]:
+                if not B[row, col_indices[-2]] and B[row, col_indices[-1]]:
+                    break
+                row -= 1
+            assert row > row_indices[-1]
+
+            col_indices.append(col)
+            row_indices.append(row)
+
+        l = len(row_indices)
+        cycle = []
+        for i in range(l):
+            if i % 2 == 0:
+                cycle.append(row_vertices[row_indices[i]])
+            else:
+                cycle.append(col_vertices[col_indices[i]])
+        for i in reversed(range(l)):
+            if i % 2 == 0:
+                cycle.append(col_vertices[col_indices[i]])
+            else:
+                cycle.append(row_vertices[row_indices[i]])
+
+        return False, cycle
+
     @doc_index("Connectivity, orientations, trees")
     def degree_constrained_subgraph(self, bounds, solver=None, verbose=0,
                                     *, integrality_tolerance=1e-3):
@@ -4786,6 +5032,9 @@ class Graph(GenericGraph):
         The diameter is defined to be the maximum distance between two vertices.
         It is infinite if the graph is not connected.
 
+        The default algorithm is ``'iFUB'`` [CGILM2010]_ for unweighted graphs
+        and ``'DHV'`` [Dragan2018]_ for weighted graphs.
+
         For more information and examples on how to use input variables, see
         :meth:`~GenericGraph.shortest_paths` and
         :meth:`~Graph.eccentricity`
@@ -4876,6 +5125,12 @@ class Graph(GenericGraph):
             Traceback (most recent call last):
             ...
             ValueError: algorithm 'iFUB' does not work on weighted graphs
+
+        Check that :issue:`40013` is fixed::
+
+            sage: G = graphs.PetersenGraph()
+            sage: G.diameter(by_weight=True)
+            2.0
         """
         if not self.order():
             raise ValueError("diameter is not defined for the empty graph")
@@ -4888,10 +5143,7 @@ class Graph(GenericGraph):
             weight_function = None
 
         if algorithm is None:
-            if by_weight:
-                algorithm = 'iFUB'
-            else:
-                algorithm = 'DHV'
+            algorithm = 'DHV' if by_weight else 'iFUB'
         elif algorithm == 'BFS':
             algorithm = 'standard'
 
@@ -5545,7 +5797,7 @@ class Graph(GenericGraph):
         """
         from sage.graphs.print_graphs import print_graph_eps
         pos = self.layout(**options)
-        [xmin, xmax, ymin, ymax] = self._layout_bounding_box(pos)
+        xmin, xmax, ymin, ymax = self._layout_bounding_box(pos)
         for v in pos:
             pos[v] = (1.8*(pos[v][0] - xmin)/(xmax - xmin) - 0.9, 1.8*(pos[v][1] - ymin)/(ymax - ymin) - 0.9)
         if filename[-4:] != '.eps':
@@ -7859,6 +8111,26 @@ class Graph(GenericGraph):
             sage: g.edge_connectivity() == min(t.edge_labels()) or not g.is_connected()
             True
 
+        If the graph has an edge whose removal increases the number of connected
+        components, the flow between the parts separated by this edge is one::
+
+            sage: g = Graph()
+            sage: g.add_clique([1, 2, 3, 4])
+            sage: g.add_clique([5, 6, 7, 8])
+            sage: g.add_edge(1, 5)
+            sage: t = g.gomory_hu_tree()
+            sage: t.edge_label(1, 5)
+            1
+            sage: g.flow(randint(1, 4), randint(5, 8)) == t.edge_label(1, 5)
+            True
+            sage: for u, v in g.edge_iterator(labels=False):
+            ....:     g.set_edge_label(u, v, 3)
+            sage: t = g.gomory_hu_tree()
+            sage: t.edge_label(1, 5)
+            3
+            sage: g.flow(randint(1, 4), randint(5, 8)) == t.edge_label(1, 5)
+            True
+
         TESTS:
 
         :issue:`16475`::
@@ -7888,11 +8160,22 @@ class Graph(GenericGraph):
 
         # We use a stack to avoid recursion. An element of the stack contains
         # the graph to be processed and the corresponding set of "real" vertices
-        # (as opposed to the fakes one introduced during the computations.
-        if self.is_connected():
+        # (as opposed to the fakes one introduced during the computations).
+        blocks = self.blocks_and_cut_vertices()[0]
+        if len(blocks) == 1 and len(blocks[0]) == self.order():
+            # The graph is biconnected
             stack = [(self, frozenset(self))]
         else:
-            stack = [(cc, frozenset(cc)) for cc in self.connected_components_subgraphs()]
+            stack = []
+            for block in blocks:
+                if len(block) == 2:
+                    # This block is a cut-edge. It corresponds to an edge of the
+                    # tree with capacity 1 if the label is None
+                    u, v = block
+                    label = self.edge_label(u, v)
+                    T.add_edge(u, v, 1 if label is None else label)
+                else:
+                    stack.append((self.subgraph(block), frozenset(block)))
 
         # We now iteratively decompose the graph to build the tree
         while stack:

sage/graphs/graph_database.py

@@ -45,10 +45,9 @@ REFERENCES:
 # Distributed  under  the  terms  of  the  GNU  General  Public  License (GPL)
 #                         https://www.gnu.org/licenses/
 # ##############################################################################
+import re
 
 from . import graph
-import os
-import re
 from sage.rings.integer import Integer
 from sage.databases.sql_db import SQLDatabase, SQLQuery
 from sage.features.databases import DatabaseGraphs
@@ -323,8 +322,9 @@ class GenericGraphQuery(SQLQuery):
 
 class GraphQuery(GenericGraphQuery):
 
-    def __init__(self, graph_db=None, query_dict=None, display_cols=None, **kwds):
-        """
+    def __init__(self, graph_db=None, query_dict=None, display_cols=None,
+                 immutable=False, **kwds):
+        r"""
         A query for an instance of :class:`~GraphDatabase`.
 
         This class nicely wraps the :class:`sage.databases.sql_db.SQLQuery`
@@ -355,6 +355,9 @@ class GraphQuery(GenericGraphQuery):
           column names (strings) to display in the result when running or
           showing a query
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          immutable or mutable graphs
+
         - ``kwds`` -- the columns of the database are all keywords. For a
           database table/column structure dictionary, call
           :func:`~graph_db_info`. Keywords accept both single values and lists
@@ -416,7 +419,17 @@ class GraphQuery(GenericGraphQuery):
             F_?@w                7                    [1, 1, 1, 1, 1, 1, 4]
             F_?Hg                7                    [1, 1, 1, 1, 1, 2, 3]
             F_?XO                7                    [1, 1, 1, 1, 2, 2, 2]
+
+        Check the behavior of parameter ``immutable``::
+
+            sage: Q = GraphQuery(display_cols=['graph6'], num_vertices=3)
+            sage: any(g.is_immutable() for g in Q)
+            False
+            sage: Q = GraphQuery(display_cols=['graph6'], num_vertices=3, immutable=True)
+            sage: all(g.is_immutable() for g in Q)
+            True
         """
+        self._immutable = immutable
         if graph_db is None:
             graph_db = GraphDatabase()
         if query_dict is not None:
@@ -537,10 +550,16 @@ class GraphQuery(GenericGraphQuery):
                                                self.__query_string__)
                 self.__query_string__ += ' ORDER BY graph_data.graph6'
 
-    def query_iterator(self):
+    def query_iterator(self, immutable=None):
         """
         Return an iterator over the results list of the :class:`~GraphQuery`.
 
+        INPUT:
+
+        - ``immutable`` -- boolean (default: ``None``); whether to create
+          mutable/immutable graphs. By default (``immutable=None``), follow the
+          behavior of ``self``.
+
         EXAMPLES::
 
             sage: Q = GraphQuery(display_cols=['graph6'], num_vertices=7, diameter=5)
@@ -569,8 +588,27 @@ class GraphQuery(GenericGraphQuery):
             FEOhW
             FGC{o
             FIAHo
+
+        Check the behavior of parameter ``immutable``::
+
+            sage: Q = GraphQuery(display_cols=['graph6'], num_vertices=3)
+            sage: any(g.is_immutable() for g in Q.query_iterator())
+            False
+            sage: all(g.is_immutable() for g in Q.query_iterator(immutable=True))
+            True
+            sage: Q = GraphQuery(display_cols=['graph6'], num_vertices=3, immutable=True)
+            sage: all(g.is_immutable() for g in Q.query_iterator())
+            True
+            sage: any(g.is_immutable() for g in Q.query_iterator(immutable=False))
+            False
         """
-        return iter(self.get_graphs_list())
+        if immutable is None:
+            immutable = self._immutable
+        s = self.__query_string__
+        re.sub('SELECT.*FROM ', 'SELECT graph6 FROM ', s)
+        q = GenericGraphQuery(s, self.__database__, self.__param_tuple__)
+        for g in q.query_results():
+            yield Graph(str(g[0]), immutable=immutable)
 
     __iter__ = query_iterator
 
@@ -690,10 +728,16 @@ class GraphQuery(GenericGraphQuery):
                           format_cols=format_cols, relabel_cols=relabel,
                           id_col='graph6')
 
-    def get_graphs_list(self):
+    def get_graphs_list(self, immutable=None):
         """
         Return a list of Sage Graph objects that satisfy the query.
 
+        INPUT:
+
+        - ``immutable`` -- boolean (default: ``None``); whether to create
+          mutable/immutable graphs. By default (``immutable=None``), follow the
+          behavior of ``self``.
+
         EXAMPLES::
 
             sage: Q = GraphQuery(display_cols=['graph6', 'num_vertices', 'degree_sequence'], num_edges=['<=', 5], min_degree=1)
@@ -702,12 +746,23 @@ class GraphQuery(GenericGraphQuery):
             Graph on 2 vertices
             sage: len(L)
             35
+
+        Check the behavior of parameter ``immutable``::
+
+            sage: Q = GraphQuery(display_cols=['graph6'], num_vertices=3)
+            sage: any(g.is_immutable() for g in Q.get_graphs_list())
+            False
+            sage: all(g.is_immutable() for g in Q.get_graphs_list(immutable=True))
+            True
+            sage: Q = GraphQuery(display_cols=['graph6'], num_vertices=3, immutable=True)
+            sage: all(g.is_immutable() for g in Q.get_graphs_list())
+            True
+            sage: any(g.is_immutable() for g in Q.get_graphs_list(immutable=False))
+            False
         """
-        s = self.__query_string__
-        re.sub('SELECT.*FROM ', 'SELECT graph6 FROM ', s)
-        q = GenericGraphQuery(s, self.__database__, self.__param_tuple__)
-        graph6_list = q.query_results()
-        return [Graph(str(g[0])) for g in graph6_list]
+        if immutable is None:
+            immutable = self._immutable
+        return list(self.query_iterator(immutable=immutable))
 
     def number_of(self):
         """