Reducing dependency on our own graph.Graph class in favor of networks

1. links.simplify does not use it anymore, except to provide a user-facing
   method of Link.

2. Deleted the graph.Graph.one_min_cut method which has at a bug.

Author: NathanDunfield

spherogram_src/__init__.py

@@ -1,11 +1,6 @@
-from .graphs import *
 from .presentations import *
 from .links import *
 from .codecs import *
-# try:
-#     import snappy
-# except ImportError:
-#     pass
 
 # Make the module version number easily accessible.
 from . import version as _version

spherogram_src/codecs/DT.py

@@ -1,4 +1,5 @@
-from .. import FatGraph, FatEdge, Link, Crossing
+from ..graphs import FatGraph, FatEdge
+from .. import Link, Crossing
 from ..links.links import CrossingEntryPoint
 from ..links.ordered_set import OrderedSet
 from .Base64LikeDT import (decode_base64_like_DT_code, encode_base64_like_DT_code)

spherogram_src/graphs.py

@@ -34,8 +34,13 @@
 
 where x and y will be the two endpoints of the edge (ordered as
 tail, head in the case of directed edges).
+
+IMPORTANT NOTE: New code should use the standard nextworkx module
+rather that the classes here.
+
 """
 from collections import deque
+from .presentations import CyclicList
 
 try:
     import sage.all
@@ -52,20 +57,6 @@
         pass
 
 
-class CyclicList(list):
-    def __getitem__(self, n):
-        if isinstance(n, int):
-            return list.__getitem__(self, n % len(self))
-        elif isinstance(n, slice):
-            # Python3 only: in python2, __getslice__ gets called instead.
-            return list.__getitem__(self, n)
-
-    def succ(self, x):
-        return self[(self.index(x) + 1) % len(self)]
-
-    def pred(self, x):
-        return self[(self.index(x) - 1) % len(self)]
-
 
 class BaseEdge(tuple):
     """
@@ -394,112 +385,6 @@ def is_connected(self, deleted_vertices=[]):
         """
         return len(self.components(deleted_vertices)) <= 1
 
-    def one_min_cut(self, source, sink, capacity=None):
-        """
-        Find one minimal cut which separates source from sink, using
-        the classical Ford-Fulkerson algorithm.
-
-        Returns a dict containing the set of vertices on the source
-        side of the cut, the set of edges that cross the cut, a
-        maximal family of weighted edge-disjoint paths from source to
-        sink, the set of edges with non-zero residual, and the
-        associated maximum flow.
-
-        The edge capacities are supplied as a dictionary, with
-        edges as keys and the capacity of the edge as value.  If
-        no capacity dict is supplied, every edge is given capacity
-        1.  Edges omitted from the capacity dict have infinite
-        capacity.
-
-        When called as a Graph method, the flow is relative to the
-        implicit orientation of an undirected edge e from e[0] to
-        e[1].  (This is determined when the edge is first constructed
-        from a pair of vertices.) A negative flow value means the flow
-        direction is from e[1] to e[0].  When called as a DiGraph
-        method, paths are directed and flows go in the direction of
-        the directed edge.
-
-        >>> caps = {('s',0):3,('s',1):2,(0,1):2,(0,'t'):4,(1,'t'):1}
-        >>> G = Graph(caps.keys())
-        >>> cap_dict = dict((e, caps[tuple(e)]) for e in G.edges)
-        >>> flow = G.one_min_cut('s', 't', cap_dict)['flow']
-        >>> [flow[e] for e in sorted(G.edges, key=str)]
-        [-1, 4, 1, 3, 2]
-        >>> G = Digraph(caps.keys())
-        >>> cap_dict = dict((e, caps[tuple(e)]) for e in G.edges)
-        >>> flow = G.one_min_cut('s', 't', cap_dict)['flow']
-        >>> [flow[e] for e in sorted(G.edges, key=str)]
-        [0, 3, 1, 3, 1]
-        """
-        if sink == source:
-            return None
-        if capacity is None:
-            residual = dict.fromkeys(self.edges, 1)
-        else:
-            residual = dict.copy(capacity)
-            for e in self.edges:
-                if e not in residual:
-                    residual[e] = float('inf')
-        full_edges = {e for e in self.edges if residual[e] == 0}
-        children = {}
-        for vertex in self.vertices:
-            children[vertex] = set()
-        cut_set = set()
-        path_list = []
-        while True:
-            # Try to find a new path from source to sink
-            parents, cut_set, reached_sink = {}, {source}, False
-            generator = self.breadth_first_edges(
-                source=source,
-                forbidden=full_edges,
-                for_flow=True)
-            for parent, vertex, child in generator:
-                parents[child] = (parent, vertex)
-                cut_set.add(child(vertex))
-                if child(vertex) == sink:
-                    reached_sink = True
-                    break
-            # If we did not get to the sink, we visited every vertex
-            # reachable from the source, thereby providing the cut
-            # set.
-            if not reached_sink:
-                break
-            # If we got to the sink, do the bookkeeping and continue.
-            path = deque()
-            flow = residual[child]
-            while True:
-                path.appendleft((vertex, child))
-                children[vertex].add(child)
-                if vertex == source:
-                    break
-                child = parent
-                parent, vertex = parents[child]
-                flow = min(flow, residual[child])
-            for vertex, edge in path:
-                residual[edge] -= flow
-                if residual[edge] == 0:
-                    full_edges.add(edge)
-            path_list.append((flow, path))
-        # Find the cut edges.
-        cut_edges = set()
-        for vertex in cut_set:
-            cut_edges |= {edge for edge in self.edges
-                             if vertex in edge
-                             and edge(vertex) not in cut_set}
-        # Find the unsaturated edges.
-        unsaturated = [e for e in self.edges if residual[e] > 0]
-        flow_dict = dict.fromkeys(self.edges, 0)
-        # Compute the flow.
-        for flow, edges in path_list:
-            for vertex, edge in edges:
-                if vertex == edge[0]:
-                    flow_dict[edge] += flow
-                else:
-                    flow_dict[edge] -= flow
-        return {'set': cut_set, 'edges': cut_edges, 'paths': path_list,
-                'residuals': residual, 'unsaturated': unsaturated,
-                'flow': flow_dict}
-
     def reduced(self):
         R = ReducedGraph()
         for e in self.edges:
@@ -551,9 +436,9 @@ def mergeable(self):
 
     def to_networkx(self):
         """
-        Return a copy of the graph in the networkx format
+        Return a copy of the graph in the networkx format.
         """
-        G = nx.Graph()
+        G = nx.MultiGraph()
         G.add_nodes_from(self.vertices)
         G.add_edges_from(self.edges)
         return G
@@ -625,12 +510,6 @@ def embedding(self):
         if self.is_planar():
             return self._embedding
 
-    def one_min_cut(self, source, sink):
-        capacity = {e: e.multiplicity for e in self.edges}
-        cut = Graph.one_min_cut(self, source, sink, capacity)
-        cut['size'] = sum(e.multiplicity for e in cut['edges'])
-        return cut
-
     def cut_pairs(self):
         """
         Return a list of cut_pairs.  The graph is assumed to be
@@ -940,7 +819,7 @@ def DAG(self):
                 edges.add((dag_tail, dag_head))
         return Digraph(edges, self.components)
 
-    
+
 if _within_sage:
     def _to_sage(self, loops=True, multiedges=True):
         S = sage.graphs.graph.Graph(loops=loops, multiedges=multiedges)

spherogram_src/links/links_base.py

@@ -985,11 +985,11 @@ def is_alternating(self):
 
     def faces(self):
         """
-        The faces are the complementary regions of the link diagram. Each face
-        is given as a list of corners of crossings as one goes around
-        *clockwise*.  These corners are recorded as CrossingStrands,
-        where CrossingStrand(c, j) denotes the corner of the face
-        abutting crossing c between strand j and j + 1.
+        The faces are the complementary regions of the link diagram.
+        Each face is given as a list of corners of crossings as one
+        goes around *clockwise*.  These corners are recorded as
+        CrossingStrands, where CrossingStrand(c, j) denotes the corner
+        of the face abutting crossing c between strand j and j + 1.
 
         Alternatively, the sequence of CrossingStrands can be regarded
         as the *heads* of the oriented edges of the face.

spherogram_src/links/morse.py

@@ -34,7 +34,8 @@
 reduced to using a generic ILP solver.
 """
 from ..sage_helper import _within_sage
-from ..graphs import CyclicList, Digraph
+from ..graphs import Digraph
+from ..presentations import CyclicList
 from .links import CrossingStrand, Crossing, Strand, Link
 from .orthogonal import basic_topological_numbering
 from .tangles import join_strands, RationalTangle

spherogram_src/links/orthogonal.py

@@ -23,7 +23,8 @@
 import networkx
 import random
 from .links import Strand
-from ..graphs import CyclicList, Digraph
+from ..graphs import Digraph
+from ..presentations import CyclicList
 from collections import namedtuple, Counter
 
 try:

spherogram_src/links/random_links.py

@@ -9,7 +9,6 @@
 your breath, though.
 """
 import random
-from .. import graphs
 from . import links, twist
 from spherogram.planarmap import random_map as raw_random_map
 

spherogram_src/links/simplify.py

@@ -17,6 +17,52 @@
 import collections
 
 
+class DualGraphOfFaces(graphs.Graph):
+    """
+    The dual graph to a link diagram D, whose vertices correspond to
+    complementary regions (faces) of D and whose edges are dual to the
+    edges of D.
+
+    This is class is no longer used in the simplfy code, but is called
+    by Link.dual_graph.  It is the only place in this file that
+    graph.Graph is used.
+    """
+    def __init__(self, link):
+        graphs.Graph.__init__(self)
+        faces = [Face(face, i) for i, face in enumerate(link.faces())]
+        self.edge_to_face = to_face = {}
+        for face in faces:
+            for edge in face:
+                to_face[edge] = face
+
+        for edge, face in to_face.items():
+            neighbor = to_face[edge.opposite()]
+            if face.label < neighbor.label:
+                dual_edge = self.add_edge(face, neighbor)
+                dual_edge.interface = (edge, edge.opposite())
+                dual_edge.label = len(self.edges) - 1
+
+        # assert self.is_planar()
+
+    def two_cycles(self):
+        """
+        Find all two cycles and yield them as a pair of CrossingStrands which
+        are dual to the edges in the cycle.
+
+        The crossing strands are
+        oriented consistently with respect to one of the faces which a
+        vertex for the cycle.
+        """
+        for face0 in self.vertices:
+            for dual_edge0 in self.incident(face0):
+                face1 = dual_edge0(face0)
+                if face0.label < face1.label:
+                    for dual_edge1 in self.incident(face1):
+                        if dual_edge0.label < dual_edge1.label and dual_edge1(face1) == face0:
+                            yield (common_element(face0, dual_edge0.interface),
+                                   common_element(face0, dual_edge1.interface))
+
+
 def remove_crossings(link, eliminate):
     """
     Deletes the given crossings. Assumes that they have already been
@@ -219,49 +265,7 @@ def __repr__(self):
         return "<F%d>" % self.label
 
 
-class DualGraphOfFaces(graphs.Graph):
-    """
-    The dual graph to a link diagram D, whose vertices correspond to
-    complementary regions (faces) of D and whose edges are dual to the
-    edges of D.
-    """
-    def __init__(self, link):
-        graphs.Graph.__init__(self)
-        faces = [Face(face, i) for i, face in enumerate(link.faces())]
-        self.edge_to_face = to_face = {}
-        for face in faces:
-            for edge in face:
-                to_face[edge] = face
-
-        for edge, face in to_face.items():
-            neighbor = to_face[edge.opposite()]
-            if face.label < neighbor.label:
-                dual_edge = self.add_edge(face, neighbor)
-                dual_edge.interface = (edge, edge.opposite())
-                dual_edge.label = len(self.edges) - 1
-
-        # assert self.is_planar()
-
-    def two_cycles(self):
-        """
-        Find all two cycles and yield them as a pair of CrossingStrands which
-        are dual to the edges in the cycle.
-
-        The crossing strands are
-        oriented consistently with respect to one of the faces which a
-        vertex for the cycle.
-        """
-        for face0 in self.vertices:
-            for dual_edge0 in self.incident(face0):
-                face1 = dual_edge0(face0)
-                if face0.label < face1.label:
-                    for dual_edge1 in self.incident(face1):
-                        if dual_edge0.label < dual_edge1.label and dual_edge1(face1) == face0:
-                            yield (common_element(face0, dual_edge0.interface),
-                                   common_element(face0, dual_edge1.interface))
-
-
-def dual_graph_as_nx(link):
+def dual_graph_as_nx(link, graph_class=nx.Graph):
     corners = OrderedSet([CrossingStrand(c, i)
                           for c in link.crossings for i in range(4)])
     faces = []
@@ -281,14 +285,15 @@ def dual_graph_as_nx(link):
                 corners.remove(next)
                 face.append(next)
 
-    G = nx.Graph()
+    G = graph_class()
     to_face = {edge: faces[f] for edge, f in to_face_index.items()}
 
     for edge, face in to_face.items():
         opp_edge = edge.opposite()
         neighbor = to_face[opp_edge]
         if face.label < neighbor.label:
             G.add_edge(face.label, neighbor.label,
+                       label=G.number_of_edges(),
                        interface={face.label: edge, neighbor.label: opp_edge})
 
     G.edge_to_face = to_face_index
@@ -299,13 +304,22 @@ def deconnect_sum(link):
     """
     Warning: Destroys the original link.
     """
-    for cs0, cs1 in DualGraphOfFaces(link).two_cycles():
-        A, a = cs0.opposite()
-        B, b = cs0
-        C, c = cs1.opposite()
-        D, d = cs1
-        A[a] = D[d]
-        B[b] = C[c]
+    G = dual_graph_as_nx(link, nx.MultiGraph)
+    for path in nx.simple_cycles(G, 2):
+        if len(path) == 2:
+            face0, face1 = path
+            edges = G[face0][face1]
+            assert len(edges) == 2
+            cs0 = edges[0]['interface'][face0]
+            cs1 = edges[1]['interface'][face0]
+
+            # Now cut and reglue.
+            A, a = cs0.opposite()
+            B, b = cs0
+            C, c = cs1.opposite()
+            D, d = cs1
+            A[a] = D[d]
+            B[b] = C[c]
     link._build_components()
     return link.split_link_diagram(destroy_original=True)