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

sage/graphs/matching_covered_graph.py

@@ -1144,27 +1144,23 @@ class MatchingCoveredGraph(Graph):
                 raise ValueError('loops are not allowed in '
                                  'matching covered graphs')
 
-            # TODO: A ligher incremental method to check whether the new graph
-            # is matching covered instead of creating a new graph and checking
+            # If (u, v, label) is a multiple edge/ an existing edge
+            if self.has_edge(u, v):
+                self._backend.add_edge(u, v, label, self._directed)
+                return
 
-            G = Graph(self, multiedges=self.allows_multiple_edges())
-            G.add_edge(u, v, label=label)
-
-            try:
-                self.__init__(data=G, matching=self.get_matching())
+            # Check if there exists an M-alternating odd uv path starting and
+            # ending with edges in self._matching
+            from sage.graphs.matching import M_alternating_even_mark
+            w = next((b if a == u else a) for a, b, *_ in self.get_matching() if u in (a, b))
 
-            except Exception:
-                raise ValueError('the graph obtained after the addition of '
-                                 'edge (%s) is not matching covered'
-                                 % str((u, v, label)))
+            if v in M_alternating_even_mark(self, w, self.get_matching()):
+                # There exists a perfect matching containing the edge (u, v, label)
+                self._backend.add_edge(u, v, label, self._directed)
+                return
 
-        else:
-            # At least one of u or v is a nonexistent vertex.
-            # Thus, the resulting graph is either disconnected
-            # or has an odd order, hence not matching covered
-            raise ValueError('the graph obtained after the addition of edge '
-                             '(%s) is not matching covered'
-                             % str((u, v, label)))
+        raise ValueError('the graph obtained after the addition of edge '
+                         '(%s) is not matching covered' % str((u, v, label)))
 
     @doc_index('Overwritten methods')
     def add_edges(self, edges, loops=False):
@@ -1180,7 +1176,8 @@ class MatchingCoveredGraph(Graph):
         INPUT:
 
         - ``edges`` -- an iterable of edges, given either as ``(u, v)``
-          or ``(u, v, 'label')``
+          or ``(u, v, 'label')``. If an edge is provided in the format
+          ``(u, v)``, the label is set to ``None``.
 
         - ``loops`` -- boolean (default: ``False``); note that this shall
           always be set to either ``False`` or ``None`` (since matching covered
@@ -1188,6 +1185,9 @@ class MatchingCoveredGraph(Graph):
           ``(v, v, 'label')`` are removed from the iterator. If ``loops`` is
           set to ``True``, a :exc:`ValueError` is thrown.
 
+        - Please note that all the loops present in the iterator are ignored,
+          provided that ``loops`` is set to ``False`` or ``None``.
+
         OUTPUT:
 
         - If ``loops`` is set to ``True``, a :exc:`ValueError` is returned.
@@ -1219,7 +1219,7 @@ class MatchingCoveredGraph(Graph):
             sage: G = MatchingCoveredGraph(S)
             sage: F = [(0, 4), (2, 4), (4, 6), (4, 7)]
             sage: G.add_edges(F)
-            sage: G.edges(sort=True)
+            sage: G.edges(sort=True, sort_vertices=True)
             [(0, 1, None), (0, 3, None), (0, 4, None), (0, 6, None),
              (1, 2, None), (1, 4, None), (2, 4, None), (2, 5, None),
              (2, 7, None), (3, 4, None), (3, 6, None), (4, 5, None),
@@ -1234,7 +1234,7 @@ class MatchingCoveredGraph(Graph):
             sage: F = [(0, 9), (1, 8), (2, 9), (3, 8),
             ....:      (4, 9), (5, 8), (6, 9), (7, 8)]
             sage: G.add_edges(F)
-            sage: G.edges(sort=True)
+            sage: G.edges(sort=True, sort_vertices=True)
             [(0, 1, None), (0, 7, None), (0, 9, None), (1, 2, None),
              (1, 8, None), (2, 3, None), (2, 9, None), (3, 4, None),
              (3, 8, None), (4, 5, None), (4, 9, None), (5, 6, None),
@@ -1249,7 +1249,7 @@ class MatchingCoveredGraph(Graph):
             sage: F = {(0, 8, None), (1, 10), (4, 11, 'label'),
             ....:      (5, 9), (8, 9), (10, 11)}
             sage: G.add_edges(F)
-            sage: G.edges(sort=True)
+            sage: G.edges(sort=True, sort_vertices=True)
             [(0, 1, None), (0, 3, None), (0, 4, None), (0, 8, None),
              (1, 2, None), (1, 5, None), (1, 10, None), (2, 3, None),
              (2, 6, None), (3, 7, None), (4, 5, None), (4, 7, None),
@@ -1295,7 +1295,7 @@ class MatchingCoveredGraph(Graph):
             sage: G = MatchingCoveredGraph(W)
             sage: F = [(0, 0), (1, 3), (2, 4)]
             sage: G.add_edges(edges=F, loops=False)
-            sage: G.edges(sort=True)
+            sage: G.edges(sort=True, sort_vertices=True)
             [(0, 1, None), (0, 2, None), (0, 3, None), (0, 4, None),
              (0, 5, None), (1, 2, None), (1, 3, None), (1, 5, None),
              (2, 3, None), (2, 4, None), (3, 4, None), (4, 5, None)]
@@ -1304,7 +1304,7 @@ class MatchingCoveredGraph(Graph):
             Traceback (most recent call last):
             ...
             ValueError: loops are not allowed in matching covered graphs
-            sage: G.edges(sort=True)
+            sage: G.edges(sort=True, sort_vertices=True)
             [(0, 1, None), (0, 2, None), (0, 3, None), (0, 4, None),
              (0, 5, None), (1, 2, None), (1, 3, None), (1, 5, None),
              (2, 3, None), (2, 4, None), (3, 4, None), (4, 5, None)]
@@ -1331,9 +1331,23 @@ class MatchingCoveredGraph(Graph):
              (0, 6, None), (1, 2, None), (1, 2, None), (1, 4, None),
              (2, 5, None), (2, 7, None), (3, 4, None), (3, 6, None),
              (4, 5, None), (5, 7, None), (6, 7, None)]
+            sage: H = [(0, 1)] * 4
+            sage: G.add_edges(H)
+            sage: G.edge_label(0, 1)
+            [None, None, None, None, None, 'label']
 
         TESTS:
 
+        Providing with a non-iterable of edges::
+
+            sage: K2 = graphs.CompleteGraph(2)
+            sage: G = MatchingCoveredGraph(K2)
+            sage: G.add_edges(1234)
+            Traceback (most recent call last):
+            ...
+            ValueError: expected an iterable of edges,
+            but got a non-iterable object
+
         Providing with an edge in ``edges`` that has 0 values to unpack::
 
             sage: W = graphs.WagnerGraph()
@@ -1341,7 +1355,7 @@ class MatchingCoveredGraph(Graph):
             sage: G.add_edges([()])
             Traceback (most recent call last):
             ...
-            ValueError: need more than 0 values to unpack
+            ValueError: need more than 1 value to unpack for edge: ()
 
         Providing with an edge in ``edges`` that has precisely one value to unpack::
 
@@ -1350,7 +1364,7 @@ class MatchingCoveredGraph(Graph):
             sage: G.add_edges([(0, )])
             Traceback (most recent call last):
             ...
-            ValueError: need more than 1 value to unpack
+            ValueError: need more than 1 value to unpack for edge: (0,)
 
         Providing with an edge in ``edges`` that has more than 3 values to unpack::
 
@@ -1359,17 +1373,17 @@ class MatchingCoveredGraph(Graph):
             sage: G.add_edges([(0, 1, 2, 3, 4)])
             Traceback (most recent call last):
             ...
-            ValueError: too many values to unpack (expected 2)
+            ValueError: too many values to unpack (expected 2) for edge: (0, 1, 2, 3, 4)
 
         Providing with an edge of unknown data type::
 
             sage: M = graphs.MurtyGraph()
             sage: G = MatchingCoveredGraph(M)
-            sage: F = ['', 'edge', None, 1234]
+            sage: F = [None, 'edge', None]
             sage: G.add_edges(F)
             Traceback (most recent call last):
             ...
-            TypeError: input edges is of unknown type
+            TypeError: input edge None is of unknown type
         """
         if loops:
             raise ValueError('loops are not allowed in '
@@ -1378,34 +1392,44 @@ class MatchingCoveredGraph(Graph):
         if not edges:  # do nothing
             return
 
-        for edge in edges:
-            if isinstance(edge, tuple):
-                if len(edge) == 0:
-                    raise ValueError('need more than 0 values to unpack')
+        from collections.abc import Iterable
+        if not isinstance(edges, Iterable):
+            raise ValueError('expected an iterable of edges, '
+                             'but got a non-iterable object')
 
-                elif len(edge) == 1:
-                    raise ValueError('need more than 1 value to unpack')
+        links = []  # to extract the nonloop input edges
+        for edge in edges:
+            if hasattr(edge, '__len__'):
+                if len(edge) <= 1:
+                    raise ValueError('need more than 1 value to unpack '
+                                     f'for edge: {edge}')
 
                 elif len(edge) > 3:
-                    raise ValueError('too many values to unpack (expected 2)')
+                    raise ValueError('too many values to unpack (expected 2) '
+                                     f'for edge: {edge}')
 
             else:
-                raise TypeError('input edges is of unknown type')
+                raise TypeError(f'input edge {edge} is of unknown type')
 
-        # Remove potentially duplicated edges
-        edges = list(set(edges))
+            u, v, l = None, None, None
 
-        # Remove all the loops from edges
-        for edge in edges:
-            if edge[0] == edge[1]:
-                edges.remove(edge)
+            if len(edge) == 2:
+                u, v = edge
+            else:
+                u, v, l = edge
 
-        # Check if all the incident vertices of the input edges are existent
-        new_vertices = list(set([x for u, v, *_ in edges for x in [u, v]]))
+            if u != v:
+                links.append((u, v, l))
 
-        for vertex in new_vertices[:]:
-            if vertex in self:
-                new_vertices.remove(vertex)
+        # If each of the input edges is existent
+        if (self.allows_multiple_edges()
+            and all(self.has_edge(*edge) for edge in links)):
+            self._backend.add_edges(links, self._directed)
+            return
+
+        # Check if all the incident vertices of the input edges are existent
+        new_vertices = {x for u, v, _ in links for x in (u, v)
+                        if x not in self}
 
         # Throw error if the no. of new vertices is odd
         if len(new_vertices) % 2:
@@ -1414,7 +1438,7 @@ class MatchingCoveredGraph(Graph):
 
         try:
             G = Graph(self, multiedges=self.allows_multiple_edges())
-            G.add_edges(edges=edges, loops=loops)
+            G.add_edges(edges=links, loops=loops)
 
             # Check if G has a vertex with at most 1 neighbor
             if any(len(G.neighbors(v)) <= 1 for v in G):
@@ -1429,14 +1453,14 @@ class MatchingCoveredGraph(Graph):
             else:
                 # Check if the existing perfect matching may be extended to a
                 # perfect matching of the new graph
-                edges_with_two_new_vertices = []
+                links_with_two_new_vertices = []
 
-                for edge in edges:
+                for edge in links:
                     if edge[0] in new_vertices and edge[1] in new_vertices:
-                        edges_with_two_new_vertices.append(edge)
+                        links_with_two_new_vertices.append(edge)
 
-                H = Graph(data=edges_with_two_new_vertices, format='list_of_edges')
-                M = Graph(self.get_matching()).union(Graph(H.matching()))
+                M = Graph(data=links_with_two_new_vertices, format='list_of_edges')
+                M.add_edges(self.get_matching())
 
                 # Check if M is a perfect matching of the resulting graph
                 if (G.order() != 2*M.size()):
@@ -1706,7 +1730,7 @@ class MatchingCoveredGraph(Graph):
             [{0}, {1}, {2, 3, 4}, {5}, {6}, {7}]
 
         For a bicritical graph (for instance, the Petersen graph), the
-        canonical parition constitutes of only singleton sets each containing
+        canonical partition constitutes of only singleton sets each containing
         an individual vertex::
 
             sage: P = graphs.PetersenGraph()
@@ -1979,7 +2003,7 @@ class MatchingCoveredGraph(Graph):
         EXAMPLES:
 
         If one specifies a perfect matching while initializing the object, the
-        value of ``self._matching`` is captures the same matching::
+        value of ``self._matching`` is the same matching::
 
             sage: P = graphs.PetersenGraph()
             sage: M = [(0, 1), (2, 3), (4, 9), (5, 7), (6, 8)]
@@ -1989,8 +2013,8 @@ class MatchingCoveredGraph(Graph):
             sage: M == sorted(G.get_matching())
             True
 
-        If no matching is specified while initilizing a matching covered graph,
-        a perfect is computed
+        If no matching is specified while initializing a matching
+        covered graph, a perfect matching is computed
         :meth:`~sage.graphs.graph.Graph.matching` and that is captured as
         ``self._matching``::
 
@@ -2192,7 +2216,7 @@ class MatchingCoveredGraph(Graph):
         return B
 
     @doc_index('Overwritten methods')
-    def has_loops(self):
+    def has_loops(self) -> bool:
         r"""
         Check whether there are loops in the (matching covered) graph.
 
@@ -2842,7 +2866,7 @@ class MatchingCoveredGraph(Graph):
             sage: G.is_brick()
             True
 
-        The triangular cicular ladder (a graph on six vertices), aka
+        The triangular circular ladder (a graph on six vertices), aka
         `\overline{C_6}` is a brick::
 
             sage: C6Bar = graphs.CircularLadderGraph(3)

sage/graphs/orientations.py

@@ -188,22 +188,9 @@ def _initialize_digraph(G, edges, name=None, weighted=None, sparse=None,
                 name=name,
                 hash_labels=hash_labels)
 
-    D.set_vertices(G.get_vertices())
-
-    attributes_to_copy = ('_assoc', '_embedding')
-    for attr in attributes_to_copy:
-        if hasattr(G, attr):
-            copy_attr = {}
-            old_attr = getattr(G, attr)
-            if isinstance(old_attr, dict):
-                for v, value in old_attr.items():
-                    try:
-                        copy_attr[v] = value.copy()
-                    except AttributeError:
-                        copy_attr[v] = copy(value)
-                setattr(D, attr, copy_attr)
-            else:
-                setattr(D, attr, copy(old_attr))
+    # Copy attributes '_assoc' and '_embedding' if set
+    D._copy_attribute_from(G, '_assoc')
+    D._copy_attribute_from(G, '_embedding')
 
     return D
 
@@ -559,13 +546,11 @@ def acyclic_orientations(G):
         # A graph without edge cannot be oriented
         return
 
-    from sage.rings.infinity import Infinity
     from sage.combinat.subset import Subsets
 
     def reorder_vertices(G):
         n = G.order()
         ko = n
-        k = n
         G_copy = G.copy()
         vertex_labels = {v: None for v in G_copy.vertices()}
 

sage/graphs/path_enumeration.pyx

@@ -1856,7 +1856,7 @@ def all_paths_iterator(self, starting_vertices=None, ending_vertices=None,
             idx_to_path[idx] = path
             pq.push((-len(path), idx))
             idx = idx + 1
-        except(StopIteration):
+        except StopIteration:
             pass
     # Since we always extract a shortest path, using a heap
     # can speed up the algorithm
@@ -1876,7 +1876,7 @@ def all_paths_iterator(self, starting_vertices=None, ending_vertices=None,
             idx_to_path[idx] = path
             pq.push((-len(path), idx))
             idx = idx + 1
-        except(StopIteration):
+        except StopIteration:
             pass
 
 

sage/graphs/strongly_regular_db.pyx

@@ -958,7 +958,7 @@ def is_complete_multipartite(int v, int k, int l, int mu):
 
         sage: from sage.graphs.strongly_regular_db import is_complete_multipartite
         sage: t = is_complete_multipartite(12,8,4,8); t
-        (<cyfunction is_complete_multipartite.<locals>.CompleteMultipartiteSRG at ...>,
+        (<...CompleteMultipartiteSRG...>,
          3,
          4)
         sage: g = t[0](*t[1:]); g
@@ -1493,7 +1493,7 @@ def is_twograph_descendant_of_srg(int v, int k0, int l, int mu):
 
         sage: from sage.graphs.strongly_regular_db import is_twograph_descendant_of_srg
         sage: t = is_twograph_descendant_of_srg(27, 10, 1, 5); t                        # needs database_graphs sage.rings.finite_rings
-        (<cyfunction is_twograph_descendant_of_srg.<locals>.la at...
+        (<...is_twograph_descendant_of_srg...>, (8,))
         sage: g = t[0](*t[1:]); g                                                       # needs database_graphs sage.rings.finite_rings
         descendant of complement(Johnson graph with parameters 8,2) at {0, 1}: Graph on 27 vertices
         sage: g.is_strongly_regular(parameters=True)                                    # needs database_graphs sage.rings.finite_rings
@@ -1663,9 +1663,9 @@ def is_switch_OA_srg(int v, int k, int l, int mu):
         sage: t[0](*t[1:]).is_strongly_regular(parameters=True)                         # needs sage.schemes
         (290, 136, 63, 64)
         sage: is_switch_OA_srg(626, 300, 143, 144)                                      # needs sage.schemes
-        (<cyfunction is_switch_OA_srg.<locals>.switch_OA_srg at ..., 12, 25)
+        (<...switch_OA_srg..., 12, 25)
         sage: is_switch_OA_srg(842, 406, 195, 196)                                      # needs sage.schemes
-        (<cyfunction is_switch_OA_srg.<locals>.switch_OA_srg at ..., 14, 29)
+        (<...switch_OA_srg..., 14, 29)
     """
     cdef int n_2_p_1 = v
     cdef int n = <int> floor(sqrt(n_2_p_1 - 1))
@@ -2618,8 +2618,8 @@ def SRG_630_85_20_10():
     hs = HoffmanSingletonGraph()
     P = list(range(5)) + list(range(30, 35))  # a Petersen in hs
     mc = [0, 1, 5, 6, 12, 13, 16, 17, 22, 23, 29, 33, 39, 42, 47]
-    assert(hs.subgraph(mc).is_regular(k=0))  # a maximum coclique
-    assert(hs.subgraph(P).is_regular(k=3))
+    assert hs.subgraph(mc).is_regular(k=0)  # a maximum coclique
+    assert hs.subgraph(P).is_regular(k=3)
     h = hs.automorphism_group().stabilizer(mc, action='OnSets')
     l = h.orbit(tuple((x[0], x[1]) for x in hs.subgraph(P).matching()),
                 "OnSetsSets")
@@ -2785,7 +2785,7 @@ def strongly_regular_graph(int v, int k, int l, int mu=-1, bint existence=False,
     - ``v``, ``k``, ``l``, ``mu`` -- ``integers`` -- note that ``mu``, if unspecified, is
       automatically determined from ``v``, ``k``, ``l``
 
-    - ``existence`` -- boolean;``False``; instead of building the graph,
+    - ``existence`` -- boolean (default: ``False``); instead of building the graph,
       return:
 
         - ``True`` -- meaning that a `(v,k,\lambda,\mu)`-strongly regular graph
@@ -2923,21 +2923,21 @@ def strongly_regular_graph_lazy(int v, int k, int l, int mu=-1, bint existence=F
         sage: # needs database_graphs
         sage: from sage.graphs.strongly_regular_db import strongly_regular_graph_lazy
         sage: g,p=strongly_regular_graph_lazy(10,6,3); g,p
-        (<cyfunction is_johnson.<locals>.<lambda> at ...>, 5)
+        (<...is_johnson...>, 5)
         sage: g(p)
         Johnson graph with parameters 5,2: Graph on 10 vertices
         sage: g,p=strongly_regular_graph_lazy(10,3,0,1); g,p
-        (<cyfunction strongly_regular_graph_lazy.<locals>.<lambda> at...>,
+        (<...strongly_regular_graph_lazy...>,
          (5,))
         sage: g(p)
         complement(Johnson graph with parameters 5,2): Graph on 10 vertices
         sage: g,p=strongly_regular_graph_lazy(12,3,2); g,p
-        (<cyfunction strongly_regular_graph_lazy.<locals>.<lambda> at...>,
+        (<...strongly_regular_graph_lazy...>,
          (3, 4))
         sage: g(p)
         complement(Multipartite Graph with set sizes [4, 4, 4]): Graph on 12 vertices
         sage: g = strongly_regular_graph_lazy(539,250,105); g                           # needs sage.combinat sage.modules
-        (<cyfunction is_twograph_descendant_of_srg.<locals>.la at...>,
+        (<...is_twograph_descendant_of_srg...>,
          5,
          11)
         sage: g[0](*g[1:])                                                              # needs sage.combinat sage.modules
@@ -3299,11 +3299,11 @@ def _check_database():
         if _brouwer_database[params]['status'] != "impossible":
             raise RuntimeError("Brouwer's db does not seem to know that {} in unfeasible".format(params))
         comment = _brouwer_database[params]['comments']
-        if ('Krein'    in comment or
+        if ('Krein' in comment or
             'Absolute' in comment or
-            'Conf'     in comment or
-            'mu=1'     in comment or
-            '&mu;=2'   in comment):
+            'Conf' in comment or
+            'mu=1' in comment or
+            '&mu;=2' in comment):
             continue
         raise RuntimeError("We detected that {} was unfeasible, but maybe we should not have".format(params))
 

sage/graphs/traversals.pyx

@@ -63,7 +63,6 @@ Methods
 
 from collections import deque
 
-from libc.string cimport memset
 from libc.stdint cimport uint32_t
 from libcpp.vector cimport vector
 from cysignals.signals cimport sig_on, sig_off
@@ -75,7 +74,6 @@ 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 init_short_digraph
 from sage.graphs.base.static_sparse_graph cimport free_short_digraph
-from sage.graphs.base.static_sparse_graph cimport out_degree
 from sage.graphs.graph_decompositions.slice_decomposition cimport \
         extended_lex_BFS
 
@@ -465,6 +463,14 @@ def lex_BFS(G, reverse=False, tree=False, initial_vertex=None, algorithm="fast")
         Traceback (most recent call last):
         ...
         ValueError: 'foo' is not a graph vertex
+
+    Check that :issue:`39934` is fixed::
+
+        sage: G = Graph(1, immutable=True)
+        sage: G.lex_BFS(algorithm='slow')
+        [0]
+        sage: G.lex_BFS(algorithm='fast')
+        [0]
     """
     if initial_vertex is not None and initial_vertex not in G:
         raise ValueError(f"'{initial_vertex}' is not a graph vertex")
@@ -475,22 +481,15 @@ def lex_BFS(G, reverse=False, tree=False, initial_vertex=None, algorithm="fast")
     if algorithm != "fast":
         raise ValueError(f"unknown algorithm '{algorithm}'")
 
-    cdef size_t n = G.order()
-
     # For algorithm "fast" we need to convert G to an undirected graph
     if G.is_directed():
         G = G.to_undirected()
 
-    # Initialize variables needed by the fast and slow algorithms
+    # Initialize variables needed by the fast algorithm
     cdef CGraphBackend Gbackend = <CGraphBackend> G._backend
     cdef CGraph cg = Gbackend.cg()
-    cdef list sigma = []
-    cdef dict predecessor = {}
-    # Initialize variables needed by the fast algorithm
     cdef vector[int] sigma_int
     cdef vector[int] pred
-    # Initialize variables needed by the slow algorithm
-    cdef dict lexicographic_label
     # Temporary variables
     cdef int vi, i, initial_v_int
 
@@ -500,9 +499,11 @@ def lex_BFS(G, reverse=False, tree=False, initial_vertex=None, algorithm="fast")
         initial_v_int = Gbackend.get_vertex(initial_vertex)
     else:
         initial_v_int = -1
+    sig_on()
     extended_lex_BFS(cg, sigma_int, NULL, initial_v_int, &pred, NULL, NULL)
-    sigma = [ Gbackend.vertex_label(vi) for vi in sigma_int ]
-    predecessor = { u: sigma[i] for u, i in zip(sigma, pred) if i != -1 }
+    sig_off()
+    cdef list sigma = [Gbackend.vertex_label(vi) for vi in sigma_int]
+    cdef dict predecessor = {u: sigma[i] for u, i in zip(sigma, pred) if i != -1}
 
     if reverse:
         sigma.reverse()

sage/graphs/tutte_polynomial.py

@@ -663,7 +663,7 @@ def _tutte_polynomial_internal(G, x, y, edge_selector, cache=None):
     ##################################
 
     # Theorem 4: from Haggard, Pearce, and Royle Note that the formula
-    # at http://homepages.ecs.vuw.ac.nz/~djp/files/TOMS10.pdf is
+    # at https://web.archive.org/web/20110401195911/http://homepages.ecs.vuw.ac.nz/~djp/files/TOMS10.pdf is
     # slightly incorrect.  The initial sum should only go to n-2
     # instead of n (allowing for the last part of the recursion).
     # Additionally, the first operand of the final product should be