okstra 0.107.2 → 0.109.0

package/runtime/python/okstra_vendor/networkx/algorithms/isomorphism/tests/test_vf2userfunc.py

@@ -0,0 +1,196 @@
+"""
+Tests for VF2 isomorphism algorithm for weighted graphs.
+"""
+
+import math
+from operator import eq
+
+import networkx as nx
+import networkx.algorithms.isomorphism as iso
+
+
+def test_simple():
+    # 16 simple tests
+    w = "weight"
+    edges = [(0, 0, 1), (0, 0, 1.5), (0, 1, 2), (1, 0, 3)]
+    for g1 in [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]:
+        g1.add_weighted_edges_from(edges)
+        g2 = g1.subgraph(g1.nodes())
+        if g1.is_multigraph():
+            em = iso.numerical_multiedge_match("weight", 1)
+        else:
+            em = iso.numerical_edge_match("weight", 1)
+        assert nx.is_isomorphic(g1, g2, edge_match=em)
+
+        for mod1, mod2 in [(False, True), (True, False), (True, True)]:
+            # mod1 tests a regular edge
+            # mod2 tests a selfloop
+            if g2.is_multigraph():
+                if mod1:
+                    data1 = {0: {"weight": 10}}
+                if mod2:
+                    data2 = {0: {"weight": 1}, 1: {"weight": 2.5}}
+            else:
+                if mod1:
+                    data1 = {"weight": 10}
+                if mod2:
+                    data2 = {"weight": 2.5}
+
+            g2 = g1.subgraph(g1.nodes()).copy()
+            if mod1:
+                if not g1.is_directed():
+                    g2._adj[1][0] = data1
+                    g2._adj[0][1] = data1
+                else:
+                    g2._succ[1][0] = data1
+                    g2._pred[0][1] = data1
+            if mod2:
+                if not g1.is_directed():
+                    g2._adj[0][0] = data2
+                else:
+                    g2._succ[0][0] = data2
+                    g2._pred[0][0] = data2
+
+            assert not nx.is_isomorphic(g1, g2, edge_match=em)
+
+
+def test_weightkey():
+    g1 = nx.DiGraph()
+    g2 = nx.DiGraph()
+
+    g1.add_edge("A", "B", weight=1)
+    g2.add_edge("C", "D", weight=0)
+
+    assert nx.is_isomorphic(g1, g2)
+    em = iso.numerical_edge_match("nonexistent attribute", 1)
+    assert nx.is_isomorphic(g1, g2, edge_match=em)
+    em = iso.numerical_edge_match("weight", 1)
+    assert not nx.is_isomorphic(g1, g2, edge_match=em)
+
+    g2 = nx.DiGraph()
+    g2.add_edge("C", "D")
+    assert nx.is_isomorphic(g1, g2, edge_match=em)
+
+
+class TestMatch_Graph:
+    def setup_method(self):
+        self.g1 = nx.Graph()
+        self.g2 = nx.Graph()
+        self.build()
+
+    def build(self):
+        self.nm = iso.categorical_node_match("color", "")
+        self.em = iso.numerical_edge_match("weight", 1)
+
+        self.g1.add_node("A", color="red")
+        self.g2.add_node("C", color="blue")
+
+        self.g1.add_edge("A", "B", weight=1)
+        self.g2.add_edge("C", "D", weight=1)
+
+    def test_noweight_nocolor(self):
+        assert nx.is_isomorphic(self.g1, self.g2)
+
+    def test_color1(self):
+        assert not nx.is_isomorphic(self.g1, self.g2, node_match=self.nm)
+
+    def test_color2(self):
+        self.g1.nodes["A"]["color"] = "blue"
+        assert nx.is_isomorphic(self.g1, self.g2, node_match=self.nm)
+
+    def test_weight1(self):
+        assert nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
+
+    def test_weight2(self):
+        self.g1.add_edge("A", "B", weight=2)
+        assert not nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
+
+    def test_colorsandweights1(self):
+        assert not nx.is_isomorphic(
+            self.g1, self.g2, node_match=self.nm, edge_match=self.em
+        )
+
+    def test_colorsandweights2(self):
+        self.g1.nodes["A"]["color"] = "blue"
+        assert nx.is_isomorphic(
+            self.g1, self.g2, node_match=self.nm, edge_match=self.em
+        )
+
+    def test_colorsandweights3(self):
+        # make the colors agree and the weights disagree
+        self.g1.nodes["A"]["color"] = "blue"
+        self.g1.add_edge("A", "B", weight=2)
+        assert not nx.is_isomorphic(
+            self.g1, self.g2, node_match=self.nm, edge_match=self.em
+        )
+
+
+class TestMatch_DiGraph(TestMatch_Graph):
+    def setup_method(self):
+        self.g1 = nx.DiGraph()
+        self.g2 = nx.DiGraph()
+        self.build()
+
+
+class TestMatch_MultiGraph:
+    def setup_method(self):
+        self.g1 = nx.MultiGraph()
+        self.g2 = nx.MultiGraph()
+        self.GM = iso.MultiGraphMatcher
+        self.build()
+
+    def build(self):
+        g1 = self.g1
+        g2 = self.g2
+
+        # We will assume integer weights only.
+        g1.add_edge("A", "B", color="green", weight=0, size=0.5)
+        g1.add_edge("A", "B", color="red", weight=1, size=0.35)
+        g1.add_edge("A", "B", color="red", weight=2, size=0.65)
+
+        g2.add_edge("C", "D", color="green", weight=1, size=0.5)
+        g2.add_edge("C", "D", color="red", weight=0, size=0.45)
+        g2.add_edge("C", "D", color="red", weight=2, size=0.65)
+
+        if g1.is_multigraph():
+            self.em = iso.numerical_multiedge_match("weight", 1)
+            self.emc = iso.categorical_multiedge_match("color", "")
+            self.emcm = iso.categorical_multiedge_match(["color", "weight"], ["", 1])
+            self.emg1 = iso.generic_multiedge_match("color", "red", eq)
+            self.emg2 = iso.generic_multiedge_match(
+                ["color", "weight", "size"],
+                ["red", 1, 0.5],
+                [eq, eq, math.isclose],
+            )
+
+    def test_weights_only(self):
+        assert nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
+
+    def test_colors_only(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emc)
+        assert gm.is_isomorphic()
+
+    def test_colorsandweights(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emcm)
+        assert not gm.is_isomorphic()
+
+    def test_generic_color_only(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emg1)
+        assert gm.is_isomorphic()
+
+    def test_generic_all_3_attr(self):
+        gm = self.GM(self.g1, self.g2, edge_match=self.emg2)
+        assert not gm.is_isomorphic()
+
+        self.g2.edges["C", "D", 0]["weight"] = 0
+        self.g2.edges["C", "D", 1]["weight"] = 1
+        self.g2.edges["C", "D", 1]["size"] = 0.35
+        assert gm.is_isomorphic()
+
+
+class TestMatch_MultiDiGraph(TestMatch_MultiGraph):
+    def setup_method(self):
+        self.g1 = nx.MultiDiGraph()
+        self.g2 = nx.MultiDiGraph()
+        self.GM = iso.MultiDiGraphMatcher
+        self.build()

package/runtime/python/okstra_vendor/networkx/algorithms/isomorphism/tree_isomorphism.py

@@ -0,0 +1,264 @@
+"""
+An algorithm for finding if two undirected trees are isomorphic,
+and if so returns an isomorphism between the two sets of nodes.
+
+This algorithm uses a routine to tell if two rooted trees (trees with a
+specified root node) are isomorphic, which may be independently useful.
+
+This implements an algorithm from:
+The Design and Analysis of Computer Algorithms
+by Aho, Hopcroft, and Ullman
+Addison-Wesley Publishing 1974
+Example 3.2 pp. 84-86.
+
+A more understandable version of this algorithm is described in:
+Homework Assignment 5
+McGill University SOCS 308-250B, Winter 2002
+by Matthew Suderman
+http://crypto.cs.mcgill.ca/~crepeau/CS250/2004/HW5+.pdf
+"""
+
+from collections import defaultdict
+
+import networkx as nx
+from networkx.utils.decorators import not_implemented_for
+
+__all__ = ["rooted_tree_isomorphism", "tree_isomorphism"]
+
+
+@nx._dispatchable(graphs={"t1": 0, "t2": 2}, returns_graph=True)
+def root_trees(t1, root1, t2, root2):
+    """Create a single digraph dT of free trees t1 and t2
+    #   with roots root1 and root2 respectively
+    # rename the nodes with consecutive integers
+    # so that all nodes get a unique name between both trees
+
+    # our new "fake" root node is 0
+    # t1 is numbers from 1 ... n
+    # t2 is numbered from n+1 to 2n
+    """
+
+    dT = nx.DiGraph()
+
+    newroot1 = 1  # left root will be 1
+    newroot2 = nx.number_of_nodes(t1) + 1  # right will be n+1
+
+    # may be overlap in node names here so need separate maps
+    # given the old name, what is the new
+    namemap1 = {root1: newroot1}
+    namemap2 = {root2: newroot2}
+
+    # add an edge from our new root to root1 and root2
+    dT.add_edge(0, namemap1[root1])
+    dT.add_edge(0, namemap2[root2])
+
+    for i, (v1, v2) in enumerate(nx.bfs_edges(t1, root1)):
+        namemap1[v2] = i + namemap1[root1] + 1
+        dT.add_edge(namemap1[v1], namemap1[v2])
+
+    for i, (v1, v2) in enumerate(nx.bfs_edges(t2, root2)):
+        namemap2[v2] = i + namemap2[root2] + 1
+        dT.add_edge(namemap2[v1], namemap2[v2])
+
+    # now we really want the inverse of namemap1 and namemap2
+    # giving the old name given the new
+    # since the values of namemap1 and namemap2 are unique
+    # there won't be collisions
+    namemap = {}
+    for old, new in namemap1.items():
+        namemap[new] = old
+    for old, new in namemap2.items():
+        namemap[new] = old
+
+    return (dT, namemap, newroot1, newroot2)
+
+
+@nx._dispatchable(graphs={"t1": 0, "t2": 2})
+def rooted_tree_isomorphism(t1, root1, t2, root2):
+    """
+    Return an isomorphic mapping between rooted trees `t1` and `t2` with roots
+    `root1` and `root2`, respectively.
+
+    These trees may be either directed or undirected,
+    but if they are directed, all edges should flow from the root.
+
+    It returns the isomorphism, a mapping of the nodes of `t1` onto the nodes
+    of `t2`, such that two trees are then identical.
+
+    Note that two trees may have more than one isomorphism, and this
+    routine just returns one valid mapping.
+    This is a subroutine used to implement `tree_isomorphism`, but will
+    be somewhat faster if you already have rooted trees.
+
+    Parameters
+    ----------
+    t1 :  NetworkX graph
+        One of the trees being compared
+
+    root1 : node
+        A node of `t1` which is the root of the tree
+
+    t2 : NetworkX graph
+        The other tree being compared
+
+    root2 : node
+        a node of `t2` which is the root of the tree
+
+    Returns
+    -------
+    isomorphism : list
+        A list of pairs in which the left element is a node in `t1`
+        and the right element is a node in `t2`.  The pairs are in
+        arbitrary order.  If the nodes in one tree is mapped to the names in
+        the other, then trees will be identical. Note that an isomorphism
+        will not necessarily be unique.
+
+        If `t1` and `t2` are not isomorphic, then it returns the empty list.
+
+    Raises
+    ------
+    NetworkXError
+        If either `t1` or `t2` is not a tree
+    """
+
+    if not nx.is_tree(t1):
+        raise nx.NetworkXError("t1 is not a tree")
+    if not nx.is_tree(t2):
+        raise nx.NetworkXError("t2 is not a tree")
+
+    # get the rooted tree formed by combining them
+    # with unique names
+    (dT, namemap, newroot1, newroot2) = root_trees(t1, root1, t2, root2)
+
+    # Group nodes by their distance from the root
+    L = defaultdict(list)
+    for n, dist in nx.shortest_path_length(dT, source=0).items():
+        L[dist].append(n)
+
+    # height
+    h = max(L)
+
+    # each node has a label, initially set to 0
+    label = {v: 0 for v in dT}
+    # and also ordered_labels and ordered_children
+    # which will store ordered tuples
+    ordered_labels = {v: () for v in dT}
+    ordered_children = {v: () for v in dT}
+
+    # nothing to do on last level so start on h-1
+    # also nothing to do for our fake level 0, so skip that
+    for i in range(h - 1, 0, -1):
+        # update the ordered_labels and ordered_children
+        # for any children
+        for v in L[i]:
+            # nothing to do if no children
+            if dT.out_degree(v) > 0:
+                # get all the pairs of labels and nodes of children and sort by labels
+                # reverse=True to preserve DFS order, see gh-7945
+                s = sorted(((label[u], u) for u in dT.successors(v)), reverse=True)
+
+                # invert to give a list of two tuples
+                # the sorted labels, and the corresponding children
+                ordered_labels[v], ordered_children[v] = list(zip(*s))
+
+        # now collect and sort the sorted ordered_labels
+        # for all nodes in L[i], carrying along the node
+        forlabel = sorted((ordered_labels[v], v) for v in L[i])
+
+        # now assign labels to these nodes, according to the sorted order
+        # starting from 0, where identical ordered_labels get the same label
+        current = 0
+        for i, (ol, v) in enumerate(forlabel):
+            # advance to next label if not 0, and different from previous
+            if (i != 0) and (ol != forlabel[i - 1][0]):
+                current += 1
+            label[v] = current
+
+    # they are isomorphic if the labels of newroot1 and newroot2 are 0
+    isomorphism = []
+    if label[newroot1] == 0 and label[newroot2] == 0:
+        # now lets get the isomorphism by walking the ordered_children
+        stack = [(newroot1, newroot2)]
+        while stack:
+            curr_v, curr_w = stack.pop()
+            isomorphism.append((curr_v, curr_w))
+            stack.extend(zip(ordered_children[curr_v], ordered_children[curr_w]))
+
+        # get the mapping back in terms of the old names
+        # return in sorted order for neatness
+        isomorphism = [(namemap[u], namemap[v]) for (u, v) in isomorphism]
+
+    return isomorphism
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+@nx._dispatchable(graphs={"t1": 0, "t2": 1})
+def tree_isomorphism(t1, t2):
+    """
+    Return an isomorphic mapping between two trees `t1` and `t2`.
+
+    If `t1` and `t2` are not isomorphic, an empty list is returned.
+    Note that two trees may have more than one isomorphism, and this routine just
+    returns one valid mapping.
+
+    Parameters
+    ----------
+    t1 : undirected NetworkX graph
+        One of the trees being compared
+
+    t2 : undirected NetworkX graph
+        The other tree being compared
+
+    Returns
+    -------
+    isomorphism : list
+        A list of pairs in which the left element is a node in `t1`
+        and the right element is a node in `t2`.  The pairs are in
+        arbitrary order.  If the nodes in one tree is mapped to the names in
+        the other, then trees will be identical. Note that an isomorphism
+        will not necessarily be unique.
+
+        If `t1` and `t2` are not isomorphic, then it returns the empty list.
+
+    Raises
+    ------
+    NetworkXError
+        If either `t1` or `t2` is not a tree
+
+    Notes
+    -----
+    This runs in ``O(n*log(n))`` time for trees with ``n`` nodes.
+    """
+    if not nx.is_tree(t1):
+        raise nx.NetworkXError("t1 is not a tree")
+    if not nx.is_tree(t2):
+        raise nx.NetworkXError("t2 is not a tree")
+
+    # To be isomorphic, t1 and t2 must have the same number of nodes and sorted
+    # degree sequences
+    if not nx.faster_could_be_isomorphic(t1, t2):
+        return []
+
+    # A tree can have either 1 or 2 centers.
+    # If the number doesn't match then t1 and t2 are not isomorphic.
+    center1 = nx.center(t1)
+    center2 = nx.center(t2)
+
+    if len(center1) != len(center2):
+        return []
+
+    # If there is only 1 center in each, then use it.
+    if len(center1) == 1:
+        return rooted_tree_isomorphism(t1, center1[0], t2, center2[0])
+
+    # If there both have 2 centers,  then try the first for t1
+    # with the first for t2.
+    attempts = rooted_tree_isomorphism(t1, center1[0], t2, center2[0])
+
+    # If that worked we're done.
+    if len(attempts) > 0:
+        return attempts
+
+    # Otherwise, try center1[0] with the center2[1], and see if that works
+    return rooted_tree_isomorphism(t1, center1[0], t2, center2[1])