passagemath-graphs 10.5.43__cp313-cp313-macosx_14_0_arm64.whl → 10.6.1rc1__cp313-cp313-macosx_14_0_arm64.whl

sage/graphs/digraph_generators.py

@@ -151,6 +151,21 @@ class DiGraphGenerators:
       dense data structure. See the documentation of
       :class:`~sage.graphs.graph.Graph`.
 
+    - ``copy`` -- boolean (default: ``True``); whether to make copies of the
+      digraphs before returning them. If set to ``False`` the method returns the
+      digraph it is working on. The second alternative is faster, but modifying
+      any of the digraph instances returned by the method may break the
+      function's behaviour, as it is using these digraphs to compute the next
+      ones: only use ``copy = False`` when you stick to *reading* the digraphs
+      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 digraphs. When set to ``True``, this parameter implies
+      ``copy=True``.
+
     EXAMPLES:
 
     Print digraphs on 2 or less vertices::
@@ -225,7 +240,7 @@ class DiGraphGenerators:
           (``vertices='vectors'``)
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         EXAMPLES::
 
@@ -339,7 +354,7 @@ class DiGraphGenerators:
         - ``n`` -- integer; number of vertices in the path
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         EXAMPLES::
 
@@ -369,7 +384,7 @@ class DiGraphGenerators:
         - ``n`` -- integer; the number of vertices of the digraph
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         .. SEEALSO::
 
@@ -421,7 +436,7 @@ class DiGraphGenerators:
         - ``q`` -- integer; the number of vertices of the digraph
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         .. SEEALSO::
 
@@ -483,7 +498,7 @@ class DiGraphGenerators:
         - ``n`` -- integer; number of vertices in the tournament
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         EXAMPLES::
 
@@ -532,7 +547,7 @@ class DiGraphGenerators:
         - ``n`` -- integer; number of vertices
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         EXAMPLES::
 
@@ -597,7 +612,7 @@ class DiGraphGenerators:
           `<https://pallini.di.uniroma1.it>`_.
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          immutable or mutable digraphs.
+          immutable or mutable digraphs
 
         EXAMPLES::
 
@@ -697,7 +712,7 @@ class DiGraphGenerators:
           standard error and standard output are displayed
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          immutable or mutable digraphs.
+          immutable or mutable digraphs
 
         EXAMPLES::
 
@@ -816,7 +831,7 @@ class DiGraphGenerators:
           beginning with ">E" indicates an error with the input.
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          immutable or mutable posets.
+          immutable or mutable posets
 
         The possible options, obtained as output of ``genposetg --help``::
 
@@ -865,7 +880,7 @@ class DiGraphGenerators:
           not, i.e., edges from `u` to itself
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         .. SEEALSO::
 
@@ -913,7 +928,7 @@ class DiGraphGenerators:
         - ``n`` -- integer; number of vertices
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         EXAMPLES:
 
@@ -952,7 +967,7 @@ class DiGraphGenerators:
           is an integer
 
         - ``immutable`` -- boolean (default: ``False``); whether to return
-          an immutable or mutable digraph.
+          an immutable or mutable digraph
 
         EXAMPLES:
 
@@ -999,7 +1014,7 @@ class DiGraphGenerators:
         G._circle_embedding(list(range(n)))
         return G
 
-    def DeBruijn(self, k, n, vertices='strings'):
+    def DeBruijn(self, k, n, vertices='strings', immutable=False):
         r"""
         Return the De Bruijn digraph with parameters `k,n`.
 
@@ -1026,6 +1041,9 @@ class DiGraphGenerators:
           are words over an alphabet (default) or integers
           (``vertices='string'``)
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          an immutable or mutable digraph
+
         EXAMPLES:
 
         de Bruijn digraph of degree 2 and diameter 2::
@@ -1079,40 +1097,48 @@ class DiGraphGenerators:
         """
         from sage.rings.integer import Integer
 
+        name = f"De Bruijn digraph (k={k}, n={n})"
         if vertices == 'strings':
             from sage.combinat.words.words import Words
 
             W = Words(list(range(k)) if isinstance(k, Integer) else k, n)
             A = Words(list(range(k)) if isinstance(k, Integer) else k, 1)
-            g = DiGraph(loops=True)
 
             if not n:
-                g.allow_multiple_edges(True)
-                v = W[0]
-                vs = v.string_rep()
-                for a in A:
-                    g.add_edge(vs, vs, a.string_rep())
+                multiedges = True
+
+                def edges():
+                    v = W[0]
+                    vs = v.string_rep()
+                    return ((vs, vs, a.string_rep()) for a in A)
+
             else:
-                for w in W:
-                    ww = w[1:]
-                    ws = w.string_rep()
-                    for a in A:
-                        g.add_edge(ws, (ww * a).string_rep(), a.string_rep())
+                multiedges = False
+
+                def edges():
+                    for w in W:
+                        ww = w[1:]
+                        ws = w.string_rep()
+                        yield from ((ws, (ww * a).string_rep(), a.string_rep())
+                                    for a in A)
+
+            return DiGraph(edges(), format='list_of_edges', name=name,
+                           loops=True, multiedges=multiedges,
+                           immutable=immutable)
 
         elif vertices == 'integers':
             d = k if isinstance(k, Integer) else len(list(k))
             if not d:
-                g = DiGraph(loops=True, multiedges=True)
-            else:
-                g = digraphs.GeneralizedDeBruijn(d ** n, d)
+                return DiGraph(loops=True, multiedges=True, name=name,
+                               immutable=immutable)
+
+            return digraphs.GeneralizedDeBruijn(d ** n, d, immutable=immutable,
+                                                name=name)
 
         else:
             raise ValueError('unknown type for vertices')
 
-        g.name("De Bruijn digraph (k={}, n={})".format(k, n))
-        return g
-
-    def GeneralizedDeBruijn(self, n, d):
+    def GeneralizedDeBruijn(self, n, d, immutable=False, name=None):
         r"""
         Return the generalized de Bruijn digraph of order `n` and degree `d`.
 
@@ -1131,6 +1157,12 @@ class DiGraphGenerators:
 
         - ``d`` -- integer; degree of the digraph (must be at least one)
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          an immutable or mutable digraph
+
+        - ``name`` -- string (default: ``None``); when set, the specified name
+          is used instead of the default one
+
         .. SEEALSO::
 
             * :meth:`sage.graphs.generic_graph.GenericGraph.is_circulant` --
@@ -1164,15 +1196,15 @@ class DiGraphGenerators:
             raise ValueError("order must be greater than or equal to one")
         if d < 1:
             raise ValueError("degree must be greater than or equal to one")
+        if name is None:
+            name = f"Generalized de Bruijn digraph (n={n}, d={d})"
 
-        GB = DiGraph(n, loops=True, multiedges=True,
-                     name="Generalized de Bruijn digraph (n={}, d={})".format(n, d))
-        for u in range(n):
-            for a in range(u * d, u * d + d):
-                GB.add_edge(u, a % n)
-        return GB
+        edges = ((u, a % n) for u in range(n) for a in range(u * d, u * d + d))
+        return DiGraph([range(n), edges], format='vertices_and_edges',
+                       loops=True, multiedges=True, immutable=immutable,
+                       name=name)
 
-    def ImaseItoh(self, n, d):
+    def ImaseItoh(self, n, d, immutable=False, name=None):
         r"""
         Return the Imase-Itoh digraph of order `n` and degree `d`.
 
@@ -1194,6 +1226,12 @@ class DiGraphGenerators:
         - ``d`` -- integer; degree of the digraph (must be greater than or
           equal to one)
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          an immutable or mutable digraph
+
+        - ``name`` -- string (default: ``None``); when set, the specified name
+          is used instead of the default one
+
         EXAMPLES::
 
             sage: II = digraphs.ImaseItoh(8, 2)
@@ -1230,15 +1268,15 @@ class DiGraphGenerators:
             raise ValueError("order must be greater than or equal to two")
         if d < 1:
             raise ValueError("degree must be greater than or equal to one")
+        if name is None:
+            name = f"Imase and Itoh digraph (n={n}, d={d})"
 
-        II = DiGraph(n, loops=True, multiedges=True,
-                     name="Imase and Itoh digraph (n={}, d={})".format(n, d))
-        for u in range(n):
-            for a in range(-u * d - d, -u * d):
-                II.add_edge(u, a % n)
-        return II
+        edges = ((u, a % n) for u in range(n) for a in range(-u * d - d, -u * d))
+        return DiGraph([range(n), edges], format='vertices_and_edges',
+                       loops=True, multiedges=True, immutable=immutable,
+                       name=name)
 
-    def Kautz(self, k, D, vertices='strings'):
+    def Kautz(self, k, D, vertices='strings', immutable=False):
         r"""
         Return the Kautz digraph of degree `d` and diameter `D`.
 
@@ -1273,6 +1311,9 @@ class DiGraphGenerators:
           are words over an alphabet (default) or integers
           (``vertices='strings'``)
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return
+          an immutable or mutable digraph
+
         EXAMPLES::
 
             sage: # needs sage.combinat
@@ -1347,6 +1388,8 @@ class DiGraphGenerators:
 
         from sage.rings.integer import Integer
 
+        name = f"Kautz digraph (k={k}, D={D})"
+
         if vertices == 'strings':
             from sage.combinat.words.words import Words
 
@@ -1364,27 +1407,26 @@ class DiGraphGenerators:
                 V = VV
 
             # We now build the set of arcs
-            G = DiGraph()
-            for u in V:
-                us = u.string_rep()
-                for a in my_alphabet:
-                    if not u.has_suffix(a):
-                        G.add_edge(us, (u[1:] * a).string_rep(),
-                                   a.string_rep())
+            def edges():
+                for u in V:
+                    us = u.string_rep()
+                    yield from ((us, (u[1:] * a).string_rep(), a.string_rep())
+                                for a in my_alphabet if not u.has_suffix(a))
+
+            return DiGraph(edges(), format='list_of_edges',
+                           name=name, immutable=immutable)
 
         elif vertices == 'integers':
             d = k if isinstance(k, Integer) else (len(list(k)) - 1)
             if d < 1:
                 raise ValueError("degree must be greater than or equal to one")
-            G = digraphs.ImaseItoh((d + 1) * (d ** (D - 1)), d)
+            return digraphs.ImaseItoh((d + 1) * (d ** (D - 1)), d,
+                                      name=name, immutable=immutable)
 
         else:
             raise ValueError('unknown type for vertices')
 
-        G.name("Kautz digraph (k={}, D={})".format(k, D))
-        return G
-
-    def RandomDirectedAcyclicGraph(self, n, p, weight_max=None):
+    def RandomDirectedAcyclicGraph(self, n, p, weight_max=None, immutable=False):
         r"""
         Return a random (weighted) directed acyclic graph of order `n`.
 
@@ -1404,6 +1446,9 @@ class DiGraphGenerators:
           unweighted. When ``weight_max`` is set to a positive integer, edges
           are assigned a random integer weight between ``1`` and ``weight_max``.
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return an
+          immutable or mutable digraph
+
         EXAMPLES::
 
             sage: D = digraphs.RandomDirectedAcyclicGraph(5, .5); D
@@ -1454,21 +1499,22 @@ class DiGraphGenerators:
         pp = int(round(float(p * RAND_MAX_f)))
 
         if weight_max is None:
-            D = DiGraph(n, name=f"RandomDAG({n}, {p})")
-            D.add_edges((i, j) for i in range(n) for j in range(i) if random() < pp)
+            name = f"RandomDAG({n}, {p})"
+            edges = ((i, j) for i in range(n) for j in range(i) if random() < pp)
 
         else:
             from sage.rings.integer_ring import ZZ
             if weight_max in ZZ and weight_max < 1:
                 raise ValueError("parameter weight_max must be a positive integer")
 
-            D = DiGraph(n, name=f"RandomWeightedDAG({n}, {p}, {weight_max})")
-            D.add_edges((i, j, randint(1, weight_max))
-                        for i in range(n) for j in range(i) if random() < pp)
+            name = f"RandomWeightedDAG({n}, {p}, {weight_max})"
+            edges = ((i, j, randint(1, weight_max))
+                     for i in range(n) for j in range(i) if random() < pp)
 
-        return D
+        return DiGraph([range(n), edges], format='vertices_and_edges',
+                       name=name, immutable=immutable)
 
-    def RandomDirectedGN(self, n, kernel=None, seed=None):
+    def RandomDirectedGN(self, n, kernel=None, seed=None, immutable=False):
         r"""
         Return a random growing network (GN) digraph with `n` vertices.
 
@@ -1488,6 +1534,9 @@ class DiGraphGenerators:
         - ``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 digraph
+
         EXAMPLES::
 
             sage: # needs networkx
@@ -1507,9 +1556,10 @@ class DiGraphGenerators:
         if seed is None:
             seed = int(current_randstate().long_seed() % sys.maxsize)
         import networkx
-        return DiGraph(networkx.gn_graph(n, kernel, seed=seed))
+        return DiGraph(networkx.gn_graph(n, kernel, seed=seed),
+                       immutable=immutable)
 
-    def RandomDirectedGNC(self, n, seed=None):
+    def RandomDirectedGNC(self, n, seed=None, immutable=False):
         r"""
         Return a random growing network with copying (GNC) digraph with `n`
         vertices.
@@ -1527,6 +1577,9 @@ class DiGraphGenerators:
         - ``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 digraph
+
         EXAMPLES::
 
             sage: # needs networkx
@@ -1540,9 +1593,9 @@ class DiGraphGenerators:
         if seed is None:
             seed = int(current_randstate().long_seed() % sys.maxsize)
         import networkx
-        return DiGraph(networkx.gnc_graph(n, seed=seed))
+        return DiGraph(networkx.gnc_graph(n, seed=seed), immutable=immutable)
 
-    def RandomDirectedGNP(self, n, p, loops=False, seed=None):
+    def RandomDirectedGNP(self, n, p, loops=False, seed=None, immutable=False):
         r"""
         Return a random digraph on `n` nodes.
 
@@ -1561,6 +1614,9 @@ class DiGraphGenerators:
         - ``seed`` -- integer (default: ``None``); seed for random number
           generator
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return an
+          immutable or mutable digraph
+
         PLOTTING: When plotting, this graph will use the default spring-layout
         algorithm, unless a position dictionary is specified.
 
@@ -1579,9 +1635,10 @@ class DiGraphGenerators:
         if seed is None:
             seed = current_randstate().long_seed()
 
-        return RandomGNP(n, p, directed=True, loops=loops, seed=seed)
+        return RandomGNP(n, p, directed=True, loops=loops, seed=seed,
+                         immutable=immutable)
 
-    def RandomDirectedGNM(self, n, m, loops=False):
+    def RandomDirectedGNM(self, n, m, loops=False, immutable=False):
         r"""
         Return a random labelled digraph on `n` nodes and `m` arcs.
 
@@ -1593,6 +1650,9 @@ class DiGraphGenerators:
 
         - ``loops`` -- boolean (default: ``False``); whether to allow loops
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return an
+          immutable or mutable digraph
+
         PLOTTING: When plotting, this graph will use the default spring-layout
         algorithm, unless a position dictionary is specified.
 
@@ -1635,10 +1695,6 @@ class DiGraphGenerators:
         # When the graph is dense, we actually compute its complement. This will
         # prevent us from drawing the same pair u,v too many times.
 
-        from sage.misc.prandom import _pyrand
-        rand = _pyrand()
-        D = DiGraph(n, loops=loops)
-
         # Ensuring the parameters n,m make sense.
         #
         # If the graph is dense, we actually want to build its complement. We
@@ -1679,9 +1735,10 @@ class DiGraphGenerators:
 
         adj = {i: dict() for i in range(n)}
 
-        # We fill the dictionary structure, but add the corresponding edge in
-        # the graph only if is_dense is False. If it is true, we will add the
-        # edges in a second phase.
+        # We fill the dictionary structure.
+
+        from sage.misc.prandom import _pyrand
+        rand = _pyrand()
 
         while m > 0:
 
@@ -1697,21 +1754,19 @@ class DiGraphGenerators:
             if (u != v or loops) and (v not in adj[u]):
                 adj[u][v] = 1
                 m -= 1
-                if not is_dense:
-                    D.add_edge(u, v)
 
-        # If is_dense is True, it means the graph has not been built. We fill D
-        # with the complement of the edges stored in the adj dictionary
+        # If is_dense is True, we fill the digraph with the complement of the
+        # edges stored in the adj dictionary
 
         if is_dense:
-            for u in range(n):
-                for v in range(n):
-                    if ((u != v) or loops) and (v not in adj[u]):
-                        D.add_edge(u, v)
+            edges = ((u, v) for u in range(n) for v in range(n)
+                     if (u != v or loops) and v not in adj[u])
+            return DiGraph([range(n), edges], format='vertices_and_edges',
+                           loops=loops, immutable=immutable)
 
-        return D
+        return DiGraph(adj, format='dict_of_lists', loops=loops)
 
-    def RandomDirectedGNR(self, n, p, seed=None):
+    def RandomDirectedGNR(self, n, p, seed=None, immutable=False):
         r"""
         Return a random growing network with redirection (GNR) digraph
         with `n` vertices and redirection probability `p`.
@@ -1731,6 +1786,9 @@ class DiGraphGenerators:
         - ``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 digraph
+
         EXAMPLES::
 
             sage: # needs networkx
@@ -1744,9 +1802,9 @@ class DiGraphGenerators:
         if seed is None:
             seed = int(current_randstate().long_seed() % sys.maxsize)
         import networkx
-        return DiGraph(networkx.gnr_graph(n, p, seed=seed))
+        return DiGraph(networkx.gnr_graph(n, p, seed=seed), immutable=immutable)
 
-    def RandomSemiComplete(self, n):
+    def RandomSemiComplete(self, n, immutable=False):
         r"""
         Return a random semi-complete digraph on `n` vertices.
 
@@ -1766,6 +1824,9 @@ class DiGraphGenerators:
 
         - ``n`` -- integer; the number of nodes
 
+        - ``immutable`` -- boolean (default: ``False``); whether to return an
+          immutable or mutable digraph
+
         .. SEEALSO::
 
             - :meth:`~sage.graphs.digraph_generators.DiGraphGenerators.Complete`
@@ -1783,22 +1844,26 @@ class DiGraphGenerators:
             ...
             ValueError: the number of vertices cannot be strictly negative
         """
-        G = DiGraph(n, name="Random Semi-Complete digraph")
+        if n < 0:
+            raise ValueError('the number of vertices cannot be strictly negative')
 
         # For each pair u,v we choose a random number ``coin`` in [1,3].
         # We select edge `(u,v)` if `coin==1` or `coin==2`.
         # We select edge `(v,u)` if `coin==2` or `coin==3`.
         import itertools
         from sage.misc.prandom import randint
-        for u, v in itertools.combinations(range(n), 2):
-            coin = randint(1, 3)
-            if coin <= 2:
-                G.add_edge(u, v)
-            if coin >= 2:
-                G.add_edge(v, u)
 
-        G._circle_embedding(list(range(n)))
+        def edges():
+            for u, v in itertools.combinations(range(n), 2):
+                coin = randint(1, 3)
+                if coin <= 2:
+                    yield (u, v)
+                if coin >= 2:
+                    yield (v, u)
 
+        G = DiGraph([range(n), edges()], format='vertices_and_edges',
+                    immutable=immutable, name="Random Semi-Complete digraph")
+        G._circle_embedding(list(range(n)))
         return G
 
 # ##############################################################################
@@ -1806,7 +1871,7 @@ class DiGraphGenerators:
 # ##############################################################################
 
     def __call__(self, vertices=None, property=lambda x: True, augment='edges',
-                 size=None, sparse=True, copy=True):
+                 size=None, sparse=True, copy=True, immutable=False):
         """
         Access the generator of isomorphism class representatives [McK1998]_.
         Iterates over distinct, exhaustive representatives.
@@ -1850,6 +1915,13 @@ class DiGraphGenerators:
           compute the next ones: only use ``copy = False`` when you stick to
           *reading* the digraphs 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 digraphs. When set to ``True``, this parameter
+          implies ``copy=True``.
+
         EXAMPLES:
 
         Print digraphs on 2 or less vertices::
@@ -1876,7 +1948,6 @@ class DiGraphGenerators:
 
             sage: digraphs?  # not tested
         """
-        from copy import copy as copyfun
         if size is not None:
             def extra_property(x):
                 return x.size() == size
@@ -1891,14 +1962,15 @@ class DiGraphGenerators:
             g = DiGraph(sparse=sparse)
             for gg in canaug_traverse_vert(g, [], vertices, property, dig=True, 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:
                 vertices = 0
                 while True:
-                    yield from self(vertices, sparse=sparse, copy=copy)
+                    yield from self(vertices, sparse=sparse, copy=copy,
+                                    immutable=immutable)
                     vertices += 1
 
             from sage.graphs.graph_generators import canaug_traverse_edge
@@ -1912,7 +1984,7 @@ class DiGraphGenerators:
                 gens.append(gen)
             for gg in canaug_traverse_edge(g, gens, property, dig=True, 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()
 

sage/graphs/dot2tex_utils.py

@@ -15,7 +15,7 @@ from sage.misc.cachefunc import cached_function
 
 
 @cached_function
-def have_dot2tex():
+def have_dot2tex() -> bool:
     """
     Return whether ``dot2tex`` >= 2.8.7 and graphviz are installed
     and functional.

sage/graphs/generators/basic.py

@@ -748,7 +748,7 @@ def CompleteMultipartiteGraph(L, immutable=False):
         ...
         ValueError: the sizes of the components must be positive integers
 
-    Check the bahavior of parameter ``immutable``::
+    Check the behaviour of parameter ``immutable``::
 
         sage: graphs.CompleteMultipartiteGraph([1], immutable=True).is_immutable()
         True

sage/graphs/generators/distance_regular.pyx

@@ -856,7 +856,7 @@ def HermitianFormsGraph(const int n, const int r):
         sage: G.is_distance_regular(True)
         ([5, 4, None], [None, 1, 2])
         sage: G = graphs.HermitianFormsGraph(3, 3)      # not tested (2 min)
-        sage: G.order()                         # not tested (bacuase of the above)
+        sage: G.order()                         # not tested (because of the above)
         19683
 
     REFERENCES: