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_list.py

@@ -19,7 +19,7 @@ AUTHORS:
 # ****************************************************************************
 
 
-def from_whatever(data):
+def from_whatever(data, immutable=False):
     r"""
     Return a list of Sage Graphs, given a list of whatever kind of data.
 
@@ -28,6 +28,9 @@ def from_whatever(data):
     - ``data`` -- can be a string, a list/iterable of strings, or a readable
       file-like object
 
+    - ``immutable`` -- boolean (default: ``False``); whether to return immutable
+      or mutable graphs
+
     EXAMPLES::
 
         sage: l = ['N@@?N@UGAGG?gGlKCMO', ':P_`cBaC_ACd`C_@BC`ABDHaEH_@BF_@CHIK_@BCEHKL_BIKM_BFGHI']
@@ -46,11 +49,20 @@ def from_whatever(data):
         sage: with open(filename) as fobj:
         ....:     graphs_list.from_whatever(fobj)
         [Graph on 15 vertices, Looped multi-graph on 17 vertices]
+
+    Check the behaviour of parameter ``immutable``::
+
+        sage: with open(filename) as fobj:
+        ....:     any(g.is_immutable() for g in graphs_list.from_whatever(fobj))
+        False
+        sage: with open(filename) as fobj:
+        ....:     all(g.is_immutable() for g in graphs_list.from_whatever(fobj, immutable=True))
+        True
     """
-    return _from_whatever(data)
+    return _from_whatever(data, immutable=immutable)
 
 
-def _from_whatever(data, fmt=None):
+def _from_whatever(data, fmt=None, immutable=False):
     """
     Implementation details of :func:`from_whatever`.
 
@@ -64,11 +76,21 @@ def _from_whatever(data, fmt=None):
       indicating that the ``Graph`` constructor should determine this for
       itself
 
+    - ``immutable`` -- boolean (default: ``False``); whether to return immutable
+      or mutable graphs
+
     EXAMPLES::
 
         sage: l = ['N@@?N@UGAGG?gGlKCMO', ':P_`cBaC_ACd`C_@BC`ABDHaEH_@BF_@CHIK_@BCEHKL_BIKM_BFGHI']
         sage: graphs_list.from_whatever(l)
         [Graph on 15 vertices, Looped multi-graph on 17 vertices]
+
+    Check the behaviour of parameter ``immutable``::
+
+        sage: any(g.is_immutable() for g in graphs_list.from_whatever(l))
+        False
+        sage: all(g.is_immutable() for g in graphs_list.from_whatever(l, immutable=True))
+        True
     """
     from sage.graphs.graph import Graph
 
@@ -110,14 +132,15 @@ def _from_whatever(data, fmt=None):
             continue
 
         if '\n' in line:
-            out.append(_from_whatever(line.splitlines(), fmt=fmt))
+            out.append(_from_whatever(line.splitlines(), fmt=fmt,
+                                      immutable=immutable))
         else:
-            out.append(Graph(line, **kwargs))
+            out.append(Graph(line, immutable=immutable, **kwargs))
 
     return out
 
 
-def from_graph6(data):
+def from_graph6(data, immutable=False):
     """
     Return a list of Sage Graphs, given a list of graph6 data.
 
@@ -125,16 +148,26 @@ def from_graph6(data):
 
     - ``data`` -- can be a string, a list of strings, or a file stream
 
+    - ``immutable`` -- boolean (default: ``False``); whether to return immutable
+      or mutable graphs
+
     EXAMPLES::
 
         sage: l = ['N@@?N@UGAGG?gGlKCMO', 'XsGGWOW?CC?C@HQKHqOjYKC_uHWGX?P?~TqIKA`OA@SAOEcEA??']
         sage: graphs_list.from_graph6(l)
         [Graph on 15 vertices, Graph on 25 vertices]
+
+    Check the behaviour of parameter ``immutable``::
+
+        sage: any(g.is_immutable() for g in graphs_list.from_graph6(l))
+        False
+        sage: all(g.is_immutable() for g in graphs_list.from_graph6(l, immutable=True))
+        True
     """
-    return _from_whatever(data, fmt='graph6')
+    return _from_whatever(data, fmt='graph6', immutable=immutable)
 
 
-def from_sparse6(data):
+def from_sparse6(data, immutable=False):
     """
     Return a list of Sage Graphs, given a list of sparse6 data.
 
@@ -142,6 +175,9 @@ def from_sparse6(data):
 
     - ``data`` -- can be a string, a list of strings, or a file stream
 
+    - ``immutable`` -- boolean (default: ``False``); whether to return immutable
+      or mutable graphs
+
     EXAMPLES::
 
         sage: g1 = ':P_`cBaC_ACd`C_@BC`ABDHaEH_@BF_@CHIK_@BCEHKL_BIKM_BFGHI'
@@ -152,8 +188,15 @@ def from_sparse6(data):
         sage: g2 += 'BA@XCs\\NggWSOJIDbHh@?A@aF'
         sage: graphs_list.from_sparse6([g1, g2])
         [Looped multi-graph on 17 vertices, Looped multi-graph on 39 vertices]
+
+    Check the behaviour of parameter ``immutable``::
+
+        sage: any(g.is_immutable() for g in graphs_list.from_sparse6([g1, g2]))
+        False
+        sage: all(g.is_immutable() for g in graphs_list.from_sparse6([g1, g2], immutable=True))
+        True
     """
-    return _from_whatever(data, fmt='sparse6')
+    return _from_whatever(data, fmt='sparse6', immutable=immutable)
 
 
 def to_graph6(graphs, file=None, output_list=False):

sage/graphs/graph_plot.py

@@ -161,6 +161,13 @@ layout_options = {
     'tree_orientation':
         'The direction of tree branches -- \'up\', \'down\', '
         '\'left\' or \'right\'.',
+    'external_face':
+        'A list of the vertices of the external face of the graph, '
+        'used for Tutte embedding layout.',
+    'external_face_pos':
+        'A dictionary specifying the positions of the external face of the '
+        'graph, used for Tutte embedding layout. If none specified, the'
+        'external face is a regular polygon.',
     'save_pos':
         'Whether or not to save the computed position for the graph.',
     'dim':

sage/graphs/hyperbolicity.pyx

@@ -1160,6 +1160,7 @@ def hyperbolicity(G,
 
     Asking for an approximation in a grid graph::
 
+        sage: # needs sage.rings.real_mpfr
         sage: from sage.graphs.hyperbolicity import hyperbolicity
         sage: G = graphs.Grid2dGraph(2, 10)
         sage: L,C,U = hyperbolicity(G, algorithm='CCL', approximation_factor=1.5); L,U
@@ -1175,6 +1176,7 @@ def hyperbolicity(G,
 
     Asking for an approximation in a cycle graph::
 
+        sage: # needs sage.rings.real_mpfr
         sage: from sage.graphs.hyperbolicity import hyperbolicity
         sage: G = graphs.CycleGraph(10)
         sage: L,C,U = hyperbolicity(G, algorithm='CCL', approximation_factor=1.5); L,U

sage/graphs/isoperimetric_inequalities.pyx

@@ -24,9 +24,11 @@ Authors:
 from cysignals.signals cimport sig_on, sig_off
 from cysignals.memory cimport check_malloc, sig_free
 
-from sage.graphs.base.static_sparse_graph cimport short_digraph, init_short_digraph, free_short_digraph
 from sage.data_structures.binary_matrix cimport *
 from sage.graphs.base.static_dense_graph cimport dense_graph_init
+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
 
 from sage.rings.infinity import Infinity
 from sage.rings.rational_field import QQ
@@ -89,6 +91,17 @@ def cheeger_constant(g):
         Traceback (most recent call last):
         ...
         ValueError: Cheeger constant is not defined for the empty graph
+
+    Immutable graph::
+
+        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.cheeger_constant() == H.cheeger_constant()
+        True
     """
     if g.is_directed():
         raise ValueError("Cheeger constant is only defined on non-oriented graph")
@@ -98,8 +111,9 @@ def cheeger_constant(g):
     elif g.num_verts() == 1:
         return Infinity
     elif not g.is_connected():
-        return QQ((0, 1))
+        return QQ.zero()
 
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd         # a copy of the graph g
     cdef int * subgraph           # vertices of the subgraph (stack)
     cdef int * bitsubgraph        # vertices of the subgraph (bit array of +1 (in) or -1 (not in))
@@ -111,7 +125,11 @@ def cheeger_constant(g):
     cdef unsigned long vmin = 1   # value of the volume for the min
     cdef int i
 
-    init_short_digraph(sd, g, edge_labelled=False, vertex_list=list(g))
+    if isinstance(g, StaticSparseBackend):
+        cg = <StaticSparseCGraph> g._cg
+        sd = <short_digraph> cg.g
+    else:
+        init_short_digraph(sd, g, edge_labelled=False, vertex_list=list(g))
 
     subgraph = <int *> check_malloc(sd.n * sizeof(int))
     bitsubgraph = <int *> check_malloc(sd.n * sizeof(int))
@@ -171,7 +189,8 @@ def cheeger_constant(g):
         return QQ((bmin, vmin))
 
     finally:
-        free_short_digraph(sd)
+        if not isinstance(g, StaticSparseBackend):
+            free_short_digraph(sd)
         sig_free(subgraph)
         sig_free(bitsubgraph)
         sig_off()
@@ -225,6 +244,17 @@ def edge_isoperimetric_number(g):
         Traceback (most recent call last):
         ...
         ValueError: edge-isoperimetric number not defined for the empty graph
+
+    Immutable graph::
+
+        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.edge_isoperimetric_number() == H.edge_isoperimetric_number()
+        True
     """
     if g.is_directed():
         raise ValueError("edge isoperimetric number is only defined on non-oriented graph")
@@ -236,6 +266,7 @@ def edge_isoperimetric_number(g):
     elif not g.is_connected():
         return QQ((0, 1))
 
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd           # a copy of the graph g
     cdef int * subgraph           # vertices of the subgraph (stack)
     cdef int * bitsubgraph        # vertices of the subgraph (bit array of +1 (in) or -1 (not in))
@@ -245,7 +276,11 @@ def edge_isoperimetric_number(g):
     cdef int u = 0                  # current vertex
     cdef int i
 
-    init_short_digraph(sd, g, edge_labelled=False, vertex_list=list(g))
+    if isinstance(g, StaticSparseBackend):
+        cg = <StaticSparseCGraph> g._cg
+        sd = <short_digraph> cg.g
+    else:
+        init_short_digraph(sd, g, edge_labelled=False, vertex_list=list(g))
 
     cdef unsigned long bmin = sd.neighbors[1] - sd.neighbors[0]  # value of boundary for the min
     cdef unsigned long vmin = 1  # value of the volume for the min
@@ -311,7 +346,8 @@ def edge_isoperimetric_number(g):
 
     finally:
         sig_off()
-        free_short_digraph(sd)
+        if not isinstance(g, StaticSparseBackend):
+            free_short_digraph(sd)
         sig_free(subgraph)
         sig_free(bitsubgraph)
 

sage/graphs/line_graph.pyx

@@ -128,6 +128,8 @@ Functions
 ---------
 """
 
+from sage.structure.element cimport parent
+
 
 def is_line_graph(g, certificate=False):
     r"""
@@ -264,21 +266,36 @@ def is_line_graph(g, certificate=False):
     return True
 
 
-def line_graph(g, labels=True):
+def line_graph(g, labels=True, return_labels=False, immutable=None):
     """
-    Return the line graph of the (di)graph ``g``.
+    Return the line graph of the (di)graph ``g`` (multiedges and loops allowed).
 
     INPUT:
 
     - ``labels`` -- boolean (default: ``True``); whether edge labels should be
       taken in consideration. If ``labels=True``, the vertices of the line graph
-      will be triples ``(u,v,label)``, and pairs of vertices otherwise.
-
-    The line graph of an undirected graph G is an undirected graph H such that
-    the vertices of H are the edges of G and two vertices e and f of H are
+      will be triples ``(u,v,label)``, and pairs of vertices otherwise.  In case
+      of multiple edges, the vertices of the line graph will be triples
+      ``(u,v,an integer)``.
+
+    - ``return_labels`` -- boolean (default: ``False``); whether edge labels should
+      be stored or not. If g has multiple edges and if ``return_labels=True``, the
+      method returns a list the first element of which is the line-graph of g
+      and the second element is a dictionary {vertex of the line-graph: former
+      corresponding edge with its original label}. If ``return_labels=False``,
+      the method returns only the line-graph.
+
+    - ``immutable`` -- boolean (default: ``None``); whether to create a
+      mutable/immutable (di)graph. ``immutable=None`` (default) means that the
+      (di)graph and its line (di)graph will behave the same way.
+
+    The line graph of an undirected graph G is an undirected simple graph H such
+    that the vertices of H are the edges of G and two vertices e and f of H are
     adjacent if e and f share a common vertex in G. In other words, an edge in H
     represents a path of length 2 in G.
 
+    Loops are not adjacent to themselves.
+
     The line graph of a directed graph G is a directed graph H such that the
     vertices of H are the edges of G and two vertices e and f of H are adjacent
     if e and f share a common vertex in G and the terminal vertex of e is the
@@ -312,7 +329,7 @@ def line_graph(g, labels=True):
          (1, 2, None),
          (1, 3, None),
          (2, 3, None)]
-        sage: h.am()                                                                    # needs sage.modules
+        sage: h.am()                                                                # needs sage.modules
         [0 1 1 1 1 0]
         [1 0 1 1 0 1]
         [1 1 0 0 1 1]
@@ -322,7 +339,7 @@ def line_graph(g, labels=True):
         sage: h2 = g.line_graph(labels=False)
         sage: h2.vertices(sort=True)
         [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
-        sage: h2.am() == h.am()                                                         # needs sage.modules
+        sage: h2.am() == h.am()                                                     # needs sage.modules
         True
         sage: g = DiGraph([[1..4], lambda i,j: i < j])
         sage: h = g.line_graph()
@@ -339,6 +356,40 @@ def line_graph(g, labels=True):
          ((1, 3, None), (3, 4, None), None),
          ((2, 3, None), (3, 4, None), None)]
 
+    Examples with multiple edges::
+
+        sage: L = Graph([(0,1),(0,1),(1,2)],multiedges=True).line_graph()
+        sage: L.edges()
+        [((0, 1, 0), (0, 1, 1), None), ((0, 1, 1), (1, 2, 2), None),
+        ((0, 1, 0), (1, 2, 2), None)]
+        sage: G = Graph([(0,1),(0,1,'a'),(0,1,'b'),(0,2),(1,2,'c')],
+        ....: multiedges=True)
+        sage: L = G.line_graph(False,True)
+        sage: L[0].edges()
+        [((0, 1, 1), (0, 1, 2), None), ((0, 1, 0), (0, 1, 2), None),
+        ((0, 1, 2), (0, 2, 3), None), ((0, 1, 2), (1, 2, 4), None), ((0, 1, 0),
+        (0, 1, 1), None), ((0, 1, 1), (0, 2, 3), None), ((0, 1, 1),
+        (1, 2, 4), None), ((0, 1, 0), (0, 2, 3), None), ((0, 1, 0),
+        (1, 2, 4), None), ((0, 2, 3), (1, 2, 4), None)]
+        sage: L[1]
+        {(0, 1, 0): (0, 1, None),
+        (0, 1, 1): (0, 1, 'b'),
+        (0, 1, 2): (0, 1, 'a'),
+        (0, 2, 3): (0, 2, None),
+        (1, 2, 4): (1, 2, 'c')}
+        sage: g = DiGraph([(0,1),(0,1),(1,2)],multiedges=True)
+        sage: g.line_graph().edges()
+        [((0, 1, 1), (1, 2, 2), None), ((0, 1, 0), (1, 2, 2), None)]
+
+    An example with a loop::
+
+        sage: g = Graph([(0,0),(0,1),(0,2),(1,2)],multiedges=True,loops=True)
+        sage: L = g.line_graph()
+        sage: L.edges()
+        [((0, 0, None), (0, 1, None), None), ((0, 0, None), (0, 2, None), None),
+        ((0, 1, None), (0, 2, None), None), ((0, 1, None), (1, 2, None), None),
+        ((0, 2, None), (1, 2, None), None)]
+
     TESTS:
 
     :issue:`13787`::
@@ -349,24 +400,64 @@ def line_graph(g, labels=True):
         True
         sage: C.line_graph().is_isomorphic(g.line_graph())
         True
+
+    Check the behavior of parameter ``immutable``::
+
+        sage: G = Graph([(0, 1), (1, 2)])
+        sage: G.line_graph().is_immutable()
+        False
+        sage: G.line_graph(immutable=True).is_immutable()
+        True
+        sage: G = Graph([(0, 1), (1, 2)], immutable=True)
+        sage: G.line_graph().is_immutable()
+        True
+        sage: G.line_graph(immutable=False).is_immutable()
+        False
+        sage: G = Graph([(0, 1), (0, 1), (1, 2)], multiedges=True)
+        sage: G.line_graph().is_immutable()
+        False
+        sage: G.line_graph(immutable=True).is_immutable()
+        True
+        sage: G = Graph([(0, 1), (0, 1), (1, 2)], multiedges=True, immutable=True)
+        sage: G.line_graph().is_immutable()
+        True
+        sage: G.line_graph(immutable=False).is_immutable()
+        False
+        sage: G = DiGraph([(0, 1), (1, 2)])
+        sage: G.line_graph().is_immutable()
+        False
+        sage: G.line_graph(immutable=True).is_immutable()
+        True
     """
     cdef dict conflicts = {}
-    cdef list elist = []
+    cdef dict origlabels_dic = {}  # stores original labels of edges in case of multiple edges
+
+    multiple = g.has_multiple_edges()
+
+    if immutable is None:
+        immutable = g.is_immutable()
+
+    if multiple:
+        # As the edges of g are the vertices of its line graph, we need to distinguish between the multiple edges of g.
+        # To this aim, we assign to each edge of g an integer label (between 0 and g.size() - 1) and set labels to True
+        # in order to keep these labels during the construction of the line graph.
+        labels = True
+        origlabels_dic = {(u, v, id): (u, v, label)
+                          for id, (u, v, label) in enumerate(g.edge_iterator())}
+        g = parent(g)([g, origlabels_dic.keys()], format='vertices_and_edges', multiedges=True)
 
-    g._scream_if_not_simple()
     if g._directed:
         from sage.graphs.digraph import DiGraph
-        G = DiGraph()
-        G.add_vertices(g.edge_iterator(labels=labels))
-        for v in g:
-            # Connect appropriate incident edges of the vertex v
-            G.add_edges((e, f) for e in g.incoming_edge_iterator(v, labels=labels)
-                        for f in g.outgoing_edge_iterator(v, labels=labels))
+        # Connect appropriate incident edges of each vertex v
+        arcs = ((e, f) for v in g
+                for e in g.incoming_edge_iterator(v, labels=labels)
+                for f in g.outgoing_edge_iterator(v, labels=labels))
+        G = DiGraph([g.edge_iterator(labels=labels), arcs],
+                    format='vertices_and_edges', immutable=immutable)
+        if return_labels and multiple:
+            return [G, origlabels_dic]
         return G
 
-    from sage.graphs.graph import Graph
-    G = Graph()
-
     # We must sort the edges' endpoints so that (1,2,None) is seen as the
     # same edge as (2,1,None).
     #
@@ -376,25 +467,27 @@ def line_graph(g, labels=True):
     # pair in the dictionary of conflicts
 
     # 1) List of vertices in the line graph
+    cdef list vertices = []
     for e in g.edge_iterator(labels=labels):
         if hash(e[0]) < hash(e[1]):
-            elist.append(e)
+            vertices.append(e)
         elif hash(e[0]) > hash(e[1]):
-            elist.append((e[1], e[0]) + e[2:])
+            vertices.append((e[1], e[0]) + e[2:])
         else:
             # Settle the conflict arbitrarily
             conflicts[e] = e
             conflicts[(e[1], e[0]) + e[2:]] = e
-            elist.append(e)
-
-    G.add_vertices(elist)
+            vertices.append(e)
 
     # 2) adjacencies in the line graph
+    cdef list edges = []
+    cdef list elist
+    from itertools import combinations
     for v in g:
         elist = []
 
         # Add the edge to the list, according to hashes, as previously
-        for e in g.edge_iterator(v, labels=labels):
+        for e in g.edge_iterator(v, labels=labels):  # iterates over the edges incident to v
             if hash(e[0]) < hash(e[1]):
                 elist.append(e)
             elif hash(e[0]) > hash(e[1]):
@@ -403,15 +496,19 @@ def line_graph(g, labels=True):
                 elist.append(conflicts[e])
 
         # All pairs of elements in elist are edges of the line graph
-        while elist:
-            x = elist.pop()
-            for y in elist:
-                G.add_edge(x, y)
+        # if g has multiple edges, some pairs appear more than once but as G is defined as simple,
+        # the corresponding edges are not added as multiedges (as it should be).
+        edges.extend(combinations(elist, 2))
 
+    from sage.graphs.graph import Graph
+    G = Graph([vertices, edges], format='vertices_and_edges',
+              immutable=immutable)
+    if return_labels and multiple:
+        return [G, origlabels_dic]
     return G
 
 
-def root_graph(g, verbose=False):
+def root_graph(g, verbose=False, immutable=None):
     r"""
     Return the root graph corresponding to the given graph ``g``.
 
@@ -424,6 +521,10 @@ def root_graph(g, verbose=False):
     - ``verbose`` -- boolean (default: ``False``); display some information
       about what is happening inside of the algorithm
 
+    - ``immutable`` -- boolean (default: ``None``); whether to create a
+      mutable/immutable (di)graph. ``immutable=None`` (default) means that the
+      (di)graph and its root (di)graph will behave the same way.
+
     .. WARNING::
 
         This code assumes that `g` is a line graph, and is a connected,
@@ -466,6 +567,19 @@ def root_graph(g, verbose=False):
         Graph on 4 vertices
         sage: G, D = root_graph(graphs.WheelGraph(5)); G
         Diamond Graph: Graph on 4 vertices
+
+    Check the behavior of parameter ``immutable``::
+
+        sage: G = graphs.CycleGraph(4)
+        sage: root_graph(G)[0].is_immutable()
+        False
+        sage: root_graph(G, immutable=True)[0].is_immutable()
+        True
+        sage: G = graphs.CycleGraph(4, immutable=True)
+        sage: root_graph(G)[0].is_immutable()
+        True
+        sage: root_graph(G, immutable=True)[0].is_immutable()
+        True
     """
     from sage.graphs.digraph import DiGraph
 
@@ -478,23 +592,26 @@ def root_graph(g, verbose=False):
     # is_line_graph expects a particular error message when g is not a line graph
     not_line_graph = "this graph is not a line graph !"
 
+    if immutable is None:
+        immutable = g.is_immutable()
+
     # Complete Graph ?
     if g.is_clique():
         from sage.graphs.generators.basic import CompleteBipartiteGraph
-        return (CompleteBipartiteGraph(1, g.order()),
+        return (CompleteBipartiteGraph(1, g.order(), immutable=immutable),
                 {v: (0, 1 + i) for i, v in enumerate(g)})
 
     # Diamond Graph ?
     elif g.order() == 4 and g.size() == 5:
         from sage.graphs.graph import Graph
-        root = Graph([(0, 1), (1, 2), (2, 0), (0, 3)])
+        root = Graph([(0, 1), (1, 2), (2, 0), (0, 3)], immutable=immutable)
         return (root,
                 g.is_isomorphic(root.line_graph(labels=False), certificate=True)[1])
 
     # Wheel on 5 vertices ?
     elif g.order() == 5 and g.size() == 8 and min(g.degree()) == 3:
         from sage.graphs.generators.basic import DiamondGraph
-        root = DiamondGraph()
+        root = DiamondGraph(immutable=immutable)
         return (root,
                 g.is_isomorphic(root.line_graph(labels=False), certificate=True)[1])
 
@@ -503,7 +620,7 @@ def root_graph(g, verbose=False):
         from sage.graphs.generators.platonic_solids import OctahedralGraph
         if g.is_isomorphic(OctahedralGraph()):
             from sage.graphs.generators.basic import CompleteGraph
-            root = CompleteGraph(4)
+            root = CompleteGraph(4, immutable=immutable)
             return (root,
                     g.is_isomorphic(root.line_graph(labels=False), certificate=True)[1])
 
@@ -592,8 +709,6 @@ def root_graph(g, verbose=False):
 
     # We now have all our cliques. Let's build the root graph to check that it
     # all fits !
-    from sage.graphs.graph import Graph
-    R = Graph()
 
     # Associates an integer to each clique
     cdef dict relabel = {}
@@ -617,7 +732,8 @@ def root_graph(g, verbose=False):
             print(v, L)
 
     # We now build R
-    R.add_edges(vertex_to_map.values())
+    from sage.graphs.graph import Graph
+    R = Graph(vertex_to_map.values(), format='list_of_edges', immutable=immutable)
 
     # If g is a line graph, then it is isomorphic to the line graph of the graph
     # R that we have constructed, so we return R (and the isomorphism).