Add algorithms for boundary.py and cuts.py (#21)

* Add algorithms for boundary.py and cuts.py

* Add tests for maxcut, which also help test cuts algorithms we just added

* Add a few more "easy" algorithms

Author: eriknw

graphblas_algorithms/algorithms/__init__.py

@@ -1,4 +1,15 @@
+from . import cluster, tournament
+from .boundary import *
 from .cluster import *
 from .core import *
+from .cuts import *
+from .dag import *
+from .dominating import *
+from .isolate import *
 from .link_analysis import *
 from .reciprocity import *
+from .regular import *
+from .simple_paths import *
+from .smetric import *
+from .structuralholes import *
+from .triads import *

graphblas_algorithms/algorithms/approximation/__init__.py

@@ -0,0 +1,2 @@
+# This helps test cuts.py
+from networkx.algorithms.approximation.tests.test_maxcut import *  # isort:skip

graphblas_algorithms/algorithms/approximation/tests/__init__.py

@@ -0,0 +1,81 @@
+import itertools
+
+from graphblas import binary
+from graphblas.semiring import any_pair
+
+from graphblas_algorithms.classes.digraph import to_graph
+from graphblas_algorithms.utils import get_all
+
+
+def edge_boundary_core(G, nbunch1, nbunch2=None, *, is_weighted=False):
+    if is_weighted:
+        B = binary.second(nbunch1 & G._A).new(name="boundary")
+    else:
+        B = binary.pair(nbunch1 & G._A).new(name="boundary")
+    if nbunch2 is None:
+        # Default nbunch2 is the complement of nbunch1.
+        # We get the row_degrees to better handle hypersparse data.
+        nbunch2 = G.get_property("row_degrees+", mask=~nbunch1.S)
+    if is_weighted:
+        B << binary.first(B & nbunch2)
+    else:
+        B << binary.pair(B & nbunch2)
+    return B
+
+
+def edge_boundary(G, nbunch1, nbunch2=None, data=False, keys=False, default=None):
+    # TODO: figure out data, keys, and default arguments and handle multigraph
+    # data=True will be tested in test_mst.py
+    is_multigraph = G.is_multigraph()
+    # This may be wrong for multi-attributed graphs
+    if data is True:
+        weight = "weight"
+    elif not data:
+        weight = None
+    else:
+        weight = data
+    G = to_graph(G, weight=weight)
+    v1 = G.set_to_vector(nbunch1, ignore_extra=True)
+    v2 = G.set_to_vector(nbunch2, ignore_extra=True)
+    result = edge_boundary_core(G, v1, v2, is_weighted=is_multigraph or data)
+    rows, cols, vals = result.to_values(values=is_multigraph or data)
+    id_to_key = G.id_to_key
+    if data:
+        it = zip(
+            (id_to_key[row] for row in rows),
+            (id_to_key[col] for col in cols),
+            # Unsure about this; data argument may mean *all* edge attributes
+            ({weight: val} for val in vals),
+        )
+    else:
+        it = zip(
+            (id_to_key[row] for row in rows),
+            (id_to_key[col] for col in cols),
+        )
+    if is_multigraph:
+        # Edge weights indicate number of times to repeat edges
+        it = itertools.chain.from_iterable(itertools.starmap(itertools.repeat, zip(it, vals)))
+    return it
+
+
+def node_boundary_core(G, nbunch1, *, mask=None):
+    if mask is None:
+        mask = ~nbunch1.S
+    else:
+        mask = mask & (~nbunch1.S)
+    bdy = any_pair(G._A.T @ nbunch1).new(mask=mask, name="boundary")
+    return bdy
+
+
+def node_boundary(G, nbunch1, nbunch2=None):
+    G = to_graph(G)
+    v1 = G.set_to_vector(nbunch1, ignore_extra=True)
+    if nbunch2 is not None:
+        mask = G.set_to_vector(nbunch2, ignore_extra=True).S
+    else:
+        mask = None
+    result = node_boundary_core(G, v1, mask=mask)
+    return G.vector_to_set(result)
+
+
+__all__ = get_all(__name__)

graphblas_algorithms/algorithms/approximation/tests/test_maxcut.py

@@ -1,5 +1,6 @@
-from graphblas import Matrix, select, monoid, semiring
-from graphblas_algorithms.classes.graph import to_undirected_graph, Graph
+from graphblas import Matrix, monoid, select, semiring
+
+from graphblas_algorithms.classes.graph import Graph, to_undirected_graph
 from graphblas_algorithms.utils import get_all, not_implemented_for
 
 

graphblas_algorithms/algorithms/boundary.py

@@ -0,0 +1,132 @@
+from graphblas import monoid
+from graphblas.semiring import any_pair, plus_first
+
+from graphblas_algorithms.classes.digraph import to_graph
+from graphblas_algorithms.utils import get_all
+
+from .boundary import edge_boundary_core, node_boundary_core
+
+
+def cut_size_core(G, S, T=None, *, is_weighted=False):
+    edges = edge_boundary_core(G, S, T, is_weighted=is_weighted)
+    if is_weighted:
+        rv = edges.reduce_scalar(monoid.plus).get(0)
+    else:
+        rv = edges.nvals
+    if G.is_directed():
+        edges = edge_boundary_core(G, T, S, is_weighted=is_weighted)
+        if is_weighted:
+            rv += edges.reduce_scalar(monoid.plus).get(0)
+        else:
+            rv += edges.nvals
+    return rv
+
+
+def cut_size(G, S, T=None, weight=None):
+    is_multigraph = G.is_multigraph()
+    G = to_graph(G, weight=weight)
+    S = G.set_to_vector(S, ignore_extra=True)
+    T = G.set_to_vector(T, ignore_extra=True)
+    return cut_size_core(G, S, T, is_weighted=is_multigraph or weight is not None)
+
+
+def volume_core(G, S, *, weighted=False):
+    if weighted:
+        degrees = plus_first(G._A @ S)
+    else:
+        degrees = G.get_property("row_degrees+", mask=S.S)
+    return degrees.reduce(monoid.plus).get(0)
+
+
+def volume(G, S, weight=None):
+    is_multigraph = G.is_multigraph()
+    G = to_graph(G, weight=weight)
+    S = G.list_to_vector(S)
+    return volume_core(G, S, weighted=is_multigraph or weight is not None)
+
+
+def normalized_cut_size_core(G, S, T=None):
+    num_cut_edges = cut_size_core(G, S, T)
+    volume_S = volume_core(G, S)
+    volume_T = volume_core(G, T)
+    return num_cut_edges * ((1 / volume_S) + (1 / volume_T))
+
+
+def normalized_cut_size(G, S, T=None, weight=None):
+    G = to_graph(G, weight=weight)
+    S = G.set_to_vector(S, ignore_extra=True)
+    if T is None:
+        T = (~S.S).new()
+    else:
+        T = G.set_to_vector(T, ignore_extra=True)
+    return normalized_cut_size_core(G, S, T)
+
+
+def conductance_core(G, S, T=None):
+    num_cut_edges = cut_size_core(G, S, T)
+    volume_S = volume_core(G, S)
+    volume_T = volume_core(G, T)
+    return num_cut_edges / min(volume_S, volume_T)
+
+
+def conductance(G, S, T=None, weight=None):
+    G = to_graph(G, weight=weight)
+    S = G.set_to_vector(S, ignore_extra=True)
+    if T is None:
+        T = (~S.S).new()
+    else:
+        T = G.set_to_vector(T, ignore_extra=True)
+    return conductance_core(G, S, T)
+
+
+def edge_expansion_core(G, S, T=None):
+    num_cut_edges = cut_size_core(G, S, T)
+    if T is None:
+        Tnvals = S.size - S.nvals
+    else:
+        Tnvals = T.nvals
+    return num_cut_edges / min(S.nvals, Tnvals)
+
+
+def edge_expansion(G, S, T=None, weight=None):
+    G = to_graph(G, weight=weight)
+    S = G.set_to_vector(S, ignore_extra=True)
+    T = G.set_to_vector(T, ignore_extra=True)
+    return edge_expansion_core(G, S, T)
+
+
+def mixing_expansion_core(G, S, T=None):
+    num_cut_edges = cut_size_core(G, S, T)
+    return num_cut_edges / G._A.nvals  # Why no factor of 2 in denominator?
+
+
+def mixing_expansion(G, S, T=None, weight=None):
+    G = to_graph(G, weight=weight)
+    S = G.set_to_vector(S, ignore_extra=True)
+    T = G.set_to_vector(T, ignore_extra=True)
+    return mixing_expansion_core(G, S, T)
+
+
+def node_expansion_core(G, S):
+    neighborhood = any_pair(G._A.T @ S)
+    return neighborhood.nvals / S.nvals
+
+
+def node_expansion(G, S):
+    G = to_graph(G)
+    S = G.list_to_vector(S)
+    return node_expansion_core(G, S)
+
+
+def boundary_expansion_core(G, S):
+    result = node_boundary_core(G, S)
+    return result.nvals / S.nvals
+
+
+def boundary_expansion(G, S):
+    G = to_graph(G)
+    S = G.set_to_vector(S, ignore_extra=True)
+    return boundary_expansion_core(G, S)
+
+
+__all__ = get_all(__name__)

graphblas_algorithms/algorithms/core.py

@@ -0,0 +1,54 @@
+from graphblas import Vector, replace
+from graphblas.semiring import any_pair
+from networkx import NetworkXError
+
+from graphblas_algorithms.classes.digraph import to_graph
+from graphblas_algorithms.utils import get_all
+
+
+# Push-pull optimization is possible, but annoying to implement
+def descendants_core(G, source):
+    if source not in G._key_to_id:
+        raise NetworkXError(f"The node {source} is not in the graph")
+    index = G._key_to_id[source]
+    A = G._A
+    q = Vector.from_values(index, True, size=A.nrows, name="q")
+    rv = q.dup(name="descendants")
+    for _ in range(A.nrows):
+        q(~rv.S, replace) << any_pair(A.T @ q)
+        if q.nvals == 0:
+            break
+        rv(q.S) << True
+    del rv[index]
+    return rv
+
+
+def descendants(G, source):
+    G = to_graph(G)
+    result = descendants_core(G, source)
+    return G.vector_to_set(result)
+
+
+def ancestors_core(G, source):
+    if source not in G._key_to_id:
+        raise NetworkXError(f"The node {source} is not in the graph")
+    index = G._key_to_id[source]
+    A = G._A
+    q = Vector.from_values(index, True, size=A.nrows, name="q")
+    rv = q.dup(name="descendants")
+    for _ in range(A.nrows):
+        q(~rv.S, replace) << any_pair(A @ q)
+        if q.nvals == 0:
+            break
+        rv(q.S) << True
+    del rv[index]
+    return rv
+
+
+def ancestors(G, source):
+    G = to_graph(G)
+    result = ancestors_core(G, source)
+    return G.vector_to_set(result)
+
+
+__all__ = get_all(__name__)

graphblas_algorithms/algorithms/cuts.py

@@ -0,0 +1,18 @@
+from graphblas.semiring import any_pair
+
+from graphblas_algorithms.classes.digraph import to_graph
+from graphblas_algorithms.utils import get_all
+
+
+def is_dominating_set_core(G, nbunch):
+    nbrs = any_pair(G._A.T @ nbunch).new(mask=~nbunch.S)  # A or A.T?
+    return nbrs.size - nbunch.nvals - nbrs.nvals == 0
+
+
+def is_dominating_set(G, nbunch):
+    G = to_graph(G)
+    v = G.set_to_vector(nbunch, ignore_extra=True)
+    return is_dominating_set_core(G, v)
+
+
+__all__ = get_all(__name__)

graphblas_algorithms/algorithms/dag.py

@@ -0,0 +1,48 @@
+from graphblas_algorithms.classes.digraph import to_graph
+from graphblas_algorithms.utils import get_all
+
+
+def is_isolate_core(G, n):
+    index = G._key_to_id[n]
+    if G.is_directed():
+        degrees = G.get_property("total_degrees+")
+    else:
+        degrees = G.get_property("degrees+")
+    return index not in degrees
+
+
+def is_isolate(G, n):
+    G = to_graph(G)
+    return is_isolate_core(G, n)
+
+
+def isolates_core(G):
+    if G.is_directed():
+        degrees = G.get_property("total_degrees+")
+    else:
+        degrees = G.get_property("degrees+")
+    return (~degrees.S).new(name="isolates")
+
+
+def isolates(G):
+    G = to_graph(G)
+    result = isolates_core(G)
+    indices, _ = result.to_values(values=False, sort=False)
+    id_to_key = G.id_to_key
+    return (id_to_key[index] for index in indices)
+
+
+def number_of_isolates_core(G):
+    if G.is_directed():
+        degrees = G.get_property("total_degrees+")
+    else:
+        degrees = G.get_property("degrees+")
+    return degrees.size - degrees.nvals
+
+
+def number_of_isolates(G):
+    G = to_graph(G)
+    return number_of_isolates_core(G)
+
+
+__all__ = get_all(__name__)