cbrkit 0.26.1__tar.gz → 0.26.2__tar.gz

{cbrkit-0.26.1 → cbrkit-0.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cbrkit
-Version: 0.26.1
+Version: 0.26.2
 Summary: Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI
 Keywords: cbr,case-based reasoning,api,similarity,nlp,retrieval,cli,tool,library
 Author: Mirko Lenz

{cbrkit-0.26.1 → cbrkit-0.26.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cbrkit"
-version = "0.26.1"
+version = "0.26.2"
 description = "Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI"
 authors = [{ name = "Mirko Lenz", email = "mirko@mirkolenz.com" }]
 readme = "README.md"

{cbrkit-0.26.1 → cbrkit-0.26.2}/src/cbrkit/sim/graphs/__init__.py

@@ -15,7 +15,7 @@ from .common import (
 from .greedy import greedy
 from .lap import lap
 from .precompute import precompute
-from .vf2 import vf2
+from .vf2 import vf2, vf2_networkx, vf2_rustworkx
 
 with optional_dependencies():
     from .alignment import dtw
@@ -34,6 +34,8 @@ __all__ = [
     "lap",
     "precompute",
     "vf2",
+    "vf2_networkx",
+    "vf2_rustworkx",
     "dtw",
     "smith_waterman",
     "init_empty",

{cbrkit-0.26.1 → cbrkit-0.26.2}/src/cbrkit/sim/graphs/astar.py

@@ -363,10 +363,6 @@ class build[K, N, E, G](
         x: Graph[K, N, E, G],
         y: Graph[K, N, E, G],
     ) -> GraphSim[K]:
-        # if len(y.nodes) + len(y.edges) > len(x.nodes) + len(x.edges):
-        #     self_inv = dataclasses.replace(self, _invert=True)
-        #     return self.invert_similarity(x, y, self_inv(x=y, y=x))
-
         node_pair_sims, edge_pair_sims = self.pair_similarities(x, y)
 
         open_set: list[PriorityState[K]] = []

{cbrkit-0.26.1 → cbrkit-0.26.2}/src/cbrkit/sim/graphs/common.py

@@ -8,12 +8,11 @@ from frozendict import frozendict
 
 from ...helpers import (
     batchify_sim,
-    reverse_batch_positional,
-    reverse_positional,
     total_params,
     unpack_float,
+    unpack_floats,
 )
-from ...model.graph import Edge, Graph, Node
+from ...model.graph import Graph, Node
 from ...typing import AnySimFunc, BatchSimFunc, Float, SimFunc, StructuredValue
 from ..wrappers import transpose_value
 
@@ -38,26 +37,38 @@ def default_element_matcher(x: Any, y: Any) -> bool:
 
 @dataclass(slots=True, frozen=True)
 class SemanticEdgeSim[K, N, E]:
-    source_weight: float = 0.5
-    target_weight: float = 0.5
+    source_weight: float = 1.0
+    target_weight: float = 1.0
+    edge_sim_func: AnySimFunc[E, Float] | None = None
 
     def __call__(
         self,
-        batches: Sequence[tuple[Edge[K, N, E], Edge[K, N, E], PairSim[K]]],
+        batches: Sequence[tuple[E, E, float, float]],
     ) -> list[float]:
-        source_sims = (
-            node_pair_sims.get((y.source.key, x.source.key), 0.0)
-            for x, y, node_pair_sims in batches
-        )
-        target_sims = (
-            node_pair_sims.get((y.target.key, x.target.key), 0.0)
-            for x, y, node_pair_sims in batches
-        )
+        source_sims = (source_sim for _, _, source_sim, _ in batches)
+        target_sims = (target_sim for _, _, _, target_sim in batches)
+
+        if self.edge_sim_func is not None:
+            edge_sim_func = batchify_sim(self.edge_sim_func)
+            edge_sims = unpack_floats(
+                edge_sim_func(
+                    [(x, y) for x, y, _, _ in batches],
+                )
+            )
+        else:
+            edge_sims = [1.0] * len(batches)
+
+        scaling_factor = self.source_weight + self.target_weight
+
+        if scaling_factor == 0:
+            return edge_sims
 
         return [
-            (self.source_weight * source + self.target_weight * target)
-            / (self.source_weight + self.target_weight)
-            for source, target in zip(source_sims, target_sims, strict=True)
+            (edge * source * self.source_weight / scaling_factor)
+            + (edge * target * self.target_weight / scaling_factor)
+            for source, target, edge in zip(
+                source_sims, target_sims, edge_sims, strict=True
+            )
         ]
 
 
@@ -82,37 +93,14 @@ def _induced_edge_mapping[K, N, E, G](
 @dataclass(slots=True)
 class BaseGraphSimFunc[K, N, E, G]:
     node_sim_func: AnySimFunc[N, Float]
-    edge_sim_func: AnySimFunc[Edge[K, N, E], Float] | SemanticEdgeSim[K, N, E] = (
-        default_edge_sim
-    )
+    edge_sim_func: SemanticEdgeSim[K, N, E] = default_edge_sim
     node_matcher: ElementMatcher[N] = default_element_matcher
     edge_matcher: ElementMatcher[E] = default_element_matcher
     batch_node_sim_func: BatchSimFunc[Node[K, N], Float] = field(init=False)
-    batch_edge_sim_func: (
-        BatchSimFunc[Edge[K, N, E], Float] | SemanticEdgeSim[K, N, E]
-    ) = field(init=False)
-    _invert: bool = False
 
     def __post_init__(self) -> None:
         self.batch_node_sim_func = batchify_sim(transpose_value(self.node_sim_func))
 
-        if isinstance(self.edge_sim_func, SemanticEdgeSim):
-            self.batch_edge_sim_func = self.edge_sim_func
-        else:
-            self.batch_edge_sim_func = batchify_sim(self.edge_sim_func)
-
-        if self._invert:
-            self.node_matcher = reverse_positional(self.node_matcher)
-            self.edge_matcher = reverse_positional(self.edge_matcher)
-            self.batch_node_sim_func = reverse_batch_positional(
-                self.batch_node_sim_func
-            )
-            if not isinstance(self.batch_edge_sim_func, SemanticEdgeSim):
-                # semantic edge sim is agnostic to order
-                self.batch_edge_sim_func = reverse_batch_positional(
-                    self.batch_edge_sim_func
-                )
-
     def induced_edge_mapping(
         self,
         x: Graph[K, N, E, G],
@@ -163,16 +151,17 @@ class BaseGraphSimFunc[K, N, E, G]:
             ]
 
         edge_pair_values = [(x.edges[x_key], y.edges[y_key]) for y_key, x_key in pairs]
-
-        if isinstance(self.batch_edge_sim_func, SemanticEdgeSim):
-            edge_pair_sims = self.batch_edge_sim_func(
-                [
-                    (x_edge, y_edge, node_pair_sims)
-                    for x_edge, y_edge in edge_pair_values
-                ]
-            )
-        else:
-            edge_pair_sims = self.batch_edge_sim_func(edge_pair_values)
+        edge_pair_sims = self.edge_sim_func(
+            [
+                (
+                    x_edge.value,
+                    y_edge.value,
+                    node_pair_sims[(y_edge.source.key, x_edge.source.key)],
+                    node_pair_sims[(y_edge.target.key, x_edge.target.key)],
+                )
+                for x_edge, y_edge in edge_pair_values
+            ]
+        )
 
         return {
             (y_edge.key, x_edge.key): unpack_float(sim)

{cbrkit-0.26.1 → cbrkit-0.26.2}/src/cbrkit/sim/graphs/dfs.py

@@ -11,8 +11,6 @@ from .common import BaseGraphSimFunc, GraphSim
 
 logger = get_logger(__name__)
 
-__all__ = ["dfs"]
-
 
 class RootsFunc[K, N, E, G](Protocol):
     """Support for matching rooted graphs
@@ -37,10 +35,10 @@ with optional_dependencies():
     class dfs[K, N, E, G](
         BaseGraphSimFunc[K, N, E, G], SimFunc[Graph[K, N, E, G], GraphSim[K]]
     ):
-        node_del_cost: float = 2.0
-        node_ins_cost: float = 0.0
-        edge_del_cost: float = 2.0
-        edge_ins_cost: float = 0.0
+        node_del_cost: float = 1.0
+        node_ins_cost: float = 1.0
+        edge_del_cost: float = 1.0
+        edge_ins_cost: float = 1.0
         max_iterations: int = 0
         upper_bound: float | None = None
         strictly_decreasing: bool = True

{cbrkit-0.26.1 → cbrkit-0.26.2}/src/cbrkit/sim/graphs/greedy.py

@@ -11,8 +11,6 @@ from .common import GraphSim, SearchGraphSimFunc, SearchState
 
 logger = get_logger(__name__)
 
-__all__ = ["greedy"]
-
 
 @dataclass(slots=True)
 class greedy[K, N, E, G](
@@ -35,10 +33,6 @@ class greedy[K, N, E, G](
         x: Graph[K, N, E, G],
         y: Graph[K, N, E, G],
     ) -> GraphSim[K]:
-        # if len(y.nodes) + len(y.edges) > len(x.nodes) + len(x.edges):
-        #     self_inv = dataclasses.replace(self, _invert=True)
-        #     return self.invert_similarity(x, y, self_inv(x=y, y=x))
-
         node_pair_sims, edge_pair_sims = self.pair_similarities(x, y)
 
         current_state = self.init_search_state(x, y)

{cbrkit-0.26.1 → cbrkit-0.26.2}/src/cbrkit/sim/graphs/lap.py

@@ -14,18 +14,17 @@ from .common import BaseGraphSimFunc, GraphSim, PairSim
 
 logger = get_logger(__name__)
 
-__all__ = ["lap"]
-
 
 # https://jack.valmadre.net/notes/2020/12/08/non-perfect-linear-assignment/
 @dataclass(slots=True)
 class lap[K, N, E, G](
     BaseGraphSimFunc[K, N, E, G], SimFunc[Graph[K, N, E, G], GraphSim[K]]
 ):
-    node_del_cost: float = 2.0
-    node_ins_cost: float = 0.0
-    edge_del_cost: float = 2.0
-    edge_ins_cost: float = 0.0
+    greedy: bool = True
+    node_del_cost: float = 1.0
+    node_ins_cost: float = 1.0
+    edge_del_cost: float = 1.0
+    edge_ins_cost: float = 1.0
     # 1.0 gives an upper bound, 0.5 gives a lower bound
     # approximation is better with a lower bound
     # since we compute real edit costs at the end anyway,
@@ -38,7 +37,7 @@ class lap[K, N, E, G](
             e.key for e in g.edges.values() if n == e.source.key or n == e.target.key
         }
 
-    def edge_sub_cost(
+    def edge_sub_cost_greedy(
         self,
         x: Graph[K, N, E, G],
         y: Graph[K, N, E, G],
@@ -46,9 +45,60 @@ class lap[K, N, E, G](
         y_node: K,
         edge_pair_sims: PairSim[K],
     ) -> float:
+        """BranchFast algorithm without solving an inner LAP problem.
+
+        - Substitutions are taken greedily in descending similarity order
+        - Unmatched y‑edges are deletions, unmatched x‑edges are insertions.
+        """
+
+        y_edges = list(self.connected_edges(y, y_node))
+        x_edges = list(self.connected_edges(x, x_node))
+
+        # trivial fast‑path
+        if not y_edges and not x_edges:
+            return 0.0
+
+        # candidate substitutions: (cost, y_key, x_key)
+        candidates: list[tuple[float, K, K]] = [
+            (1.0 - edge_pair_sims[(y_key, x_key)], y_key, x_key)
+            for y_key, x_key in itertools.product(y_edges, x_edges)
+            if (y_key, x_key) in edge_pair_sims
+        ]
+        # sort by cheapest cost  ==> highest similarity first
+        candidates.sort(key=lambda t: t[0])
+
+        matched_y: set[K] = set()
+        matched_x: set[K] = set()
+        cost = 0.0
+
+        for c, y_key, x_key in candidates:
+            if y_key not in matched_y and x_key not in matched_x:
+                matched_y.add(y_key)
+                matched_x.add(x_key)
+                cost += c  # substitution cost
+
+        # remaining deletions / insertions
+        cost += (len(y_edges) - len(matched_y)) * self.edge_del_cost
+        cost += (len(x_edges) - len(matched_x)) * self.edge_ins_cost
+
+        return cost
+
+    def edge_sub_cost_optimal(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        x_node: K,
+        y_node: K,
+        edge_pair_sims: PairSim[K],
+    ) -> float:
+        """Branch algorithm solving an inner LAP problem."""
+
         y_edges = self.connected_edges(y, y_node)
         x_edges = self.connected_edges(x, x_node)
 
+        if not y_edges and not x_edges:
+            return 0.0
+
         rows = len(y_edges)
         cols = len(x_edges)
         dim = rows + cols
@@ -126,13 +176,16 @@ class lap[K, N, E, G](
                 and (sim := node_pair_sims.get((y_key, x_key)))
             ):
                 node_sub_cost = 1.0 - sim
-                edge_sub_cost = self.edge_sub_cost(
-                    x,
-                    y,
-                    x_key,
-                    y_key,
-                    edge_pair_sims,
-                )
+
+                if self.greedy:
+                    edge_sub_cost = self.edge_sub_cost_greedy(
+                        x, y, x_key, y_key, edge_pair_sims
+                    )
+                else:
+                    edge_sub_cost = self.edge_sub_cost_optimal(
+                        x, y, x_key, y_key, edge_pair_sims
+                    )
+
                 cost[r, c] = node_sub_cost + (self.edge_edit_factor * edge_sub_cost)
 
         if self.print_matrix:

cbrkit-0.26.2/src/cbrkit/sim/graphs/precompute.py

@@ -0,0 +1,80 @@
+import itertools
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from cbrkit.helpers import chain_map_chunks, unpack_float
+
+from ...model.graph import (
+    Graph,
+    Node,
+)
+from ...typing import BatchSimFunc
+from .common import BaseGraphSimFunc
+
+
+@dataclass(slots=True)
+class precompute[K, N, E, G](
+    BaseGraphSimFunc[K, N, E, G], BatchSimFunc[Graph[K, N, E, G], float]
+):
+    precompute_nodes: bool = True
+    precompute_edges: bool = True
+
+    def __call__(
+        self, batches: Sequence[tuple[Graph[K, N, E, G], Graph[K, N, E, G]]]
+    ) -> list[float]:
+        precompute_edges = (
+            self.precompute_edges and self.edge_sim_func.edge_sim_func is not None
+        )
+        batch_node_pair_sims: list[dict[tuple[K, K], float]] = []
+
+        if self.precompute_nodes or precompute_edges:
+            batch_node_pairs: list[list[tuple[Node[K, N], Node[K, N]]]] = [
+                [
+                    (x_node, y_node)
+                    for x_node, y_node in itertools.product(
+                        x.nodes.values(), y.nodes.values()
+                    )
+                    if self.node_matcher(x_node.value, y_node.value)
+                ]
+                for x, y in batches
+            ]
+
+            batch_node_pair_sims_list = chain_map_chunks(
+                batch_node_pairs, self.batch_node_sim_func
+            )
+            batch_node_pair_sims = [
+                {
+                    (y_node.key, x_node.key): unpack_float(sim)
+                    for (x_node, y_node), sim in zip(
+                        node_pair_values, node_pair_sims, strict=True
+                    )
+                }
+                for node_pair_values, node_pair_sims in zip(
+                    batch_node_pairs, batch_node_pair_sims_list, strict=True
+                )
+            ]
+
+        if precompute_edges:
+            edge_pairs: list[tuple[E, E, float, float]] = []
+
+            for (x, y), node_pair_sims in zip(
+                batches, batch_node_pair_sims, strict=True
+            ):
+                edge_pairs.extend(
+                    (
+                        x_edge.value,
+                        y_edge.value,
+                        node_pair_sims[(y_edge.source.key, x_edge.source.key)],
+                        node_pair_sims[(y_edge.target.key, x_edge.target.key)],
+                    )
+                    for x_edge, y_edge in itertools.product(
+                        x.edges.values(), y.edges.values()
+                    )
+                    if self.edge_matcher(x_edge.value, y_edge.value)
+                    and (y_edge.source.key, x_edge.source.key) in node_pair_sims
+                    and (y_edge.target.key, x_edge.target.key) in node_pair_sims
+                )
+
+            self.edge_sim_func(edge_pairs)
+
+        return [1.0] * len(batches)

cbrkit-0.26.2/src/cbrkit/sim/graphs/qap.py

@@ -0,0 +1,145 @@
+import itertools
+from dataclasses import dataclass
+
+import numpy as np
+from frozendict import frozendict
+from scipy.optimize import quadratic_assignment
+
+from ...helpers import get_logger
+from ...model.graph import Graph
+from ...typing import SimFunc
+from .common import BaseGraphSimFunc, GraphSim
+
+logger = get_logger(__name__)
+
+
+# https://jack.valmadre.net/notes/2020/12/08/non-perfect-linear-assignment/
+@dataclass(slots=True)
+class qap[K, N, E, G](
+    BaseGraphSimFunc[K, N, E, G], SimFunc[Graph[K, N, E, G], GraphSim[K]]
+):
+    """Quadratic Assignment Problem (QAP) solver for graph similarity"""
+
+    node_del_cost: float = 1.0
+    node_ins_cost: float = 1.0
+    edge_del_cost: float = 1.0
+    edge_ins_cost: float = 1.0
+    illegal_cost: float = 1e9
+
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+    ) -> GraphSim[K]:
+        node_pair_sims, edge_pair_sims = self.pair_similarities(x, y)
+
+        n = len(y.nodes)
+        m = len(x.nodes)
+        dim = n + m
+        a = np.zeros((dim, dim), dtype=float)
+        b = np.full((dim, dim), self.illegal_cost, dtype=float)
+
+        y2idx = {k: i for i, k in enumerate(y.nodes)}
+        x2idx = {k: i for i, k in enumerate(x.nodes)}
+        idx2y = {i: k for k, i in y2idx.items()}
+        idx2x = {i: k for k, i in x2idx.items()}
+
+        # (fast look‑ups for present / absent edges)
+        y_edges = {(y2idx[e.source.key], y2idx[e.target.key]) for e in y.edges.values()}
+        x_edges = {(x2idx[e.source.key], x2idx[e.target.key]) for e in x.edges.values()}
+
+        # linear part
+        # substitution: real-real
+        for (y_key, i), (x_key, j) in itertools.product(y2idx.items(), x2idx.items()):
+            b[i, j] = (
+                1.0 - node_pair_sims[(y_key, x_key)]
+                if (y_key, x_key) in node_pair_sims
+                else self.illegal_cost
+            )
+
+        # deletion: real-dummy
+        for y_key, i in y2idx.items():
+            dummy_col = m + i
+            b[i, dummy_col] = self.node_del_cost
+            a[dummy_col, dummy_col] = 1.0  # selector
+
+        # insertion: dummy-real
+        for x_key, j in x2idx.items():
+            dummy_row = n + j
+            b[dummy_row, j] = self.node_ins_cost
+            a[dummy_row, dummy_row] = 1.0  # selector
+
+        # quadratic part
+        # real edges of y in A
+        for e in y.edges.values():
+            i, j = y2idx[e.source.key], y2idx[e.target.key]
+            a[i, j] = 1.0
+
+        # real edges of x in B
+        # not needed for directed graphs
+        # for e in x.edges.values():
+        #     i, j = x2idx[e.source.key], x2idx[e.target.key]
+        #     b[i, j] = 1.0
+
+        # edge substitution
+        for y_edge, x_edge in itertools.product(y.edges.values(), x.edges.values()):
+            iy, jy = y2idx[y_edge.source.key], y2idx[y_edge.target.key]
+            ix, jx = x2idx[x_edge.source.key], x2idx[x_edge.target.key]
+            cost = (
+                1.0 - edge_pair_sims[(y_edge.key, x_edge.key)]
+                if (y_edge.key, x_edge.key) in edge_pair_sims
+                else self.illegal_cost
+            )
+
+            # four row/col combinations induced by the permutation
+            for r, c in ((iy, ix), (iy, jx), (jy, ix), (jy, jx)):
+                # keep the *lowest* cost if collisions happen
+                b[r, c] = min(b[r, c], cost)
+
+        # edge deletion/insertion
+        for iy, jy in itertools.product(range(n), range(n)):
+            y_has = (iy, jy) in y_edges
+
+            for ix, jx in itertools.product(range(m), range(m)):
+                x_has = (ix, jx) in x_edges
+
+                if y_has and not x_has:  # deletion
+                    cost = self.edge_del_cost
+                elif not y_has and x_has:  # insertion
+                    cost = self.edge_ins_cost
+                else:  # no op
+                    continue
+
+                for r, c in ((iy, ix), (iy, jx), (jy, ix), (jy, jx)):
+                    b[r, c] = min(b[r, c], cost)
+
+        try:
+            res = quadratic_assignment(a, b, method="faq")
+        except ValueError as e:
+            logger.warning(f"Failed to compute QAP mapping for two graphs: {e}")
+
+            return GraphSim(
+                0.0,
+                frozendict(),
+                frozendict(),
+                frozendict(),
+                frozendict(),
+            )
+
+        # only consider substitutions of real nodes
+        node_mapping = frozendict(
+            (idx2y[row], idx2x[col])
+            for row, col in enumerate(res.col_ind)
+            if row < n and col < m and (idx2y[row], idx2x[col]) in node_pair_sims
+        )
+
+        edge_mapping = self.induced_edge_mapping(x, y, node_mapping)
+
+        return self.similarity(
+            x,
+            y,
+            node_mapping,
+            edge_mapping,
+            node_pair_sims,
+            edge_pair_sims,
+        )

{cbrkit-0.26.1 → cbrkit-0.26.2}/src/cbrkit/sim/graphs/vf2.py

@@ -1,4 +1,5 @@
 import itertools
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import override
 
@@ -11,27 +12,31 @@ from .common import BaseGraphSimFunc, GraphSim
 
 with optional_dependencies():
     import rustworkx
+    from networkx.algorithms.isomorphism import DiGraphMatcher
 
-    from ...model.graph import to_rustworkx_with_lookup
+    from ...model.graph import to_networkx, to_rustworkx_with_lookup
 
 
 @dataclass(slots=True)
-class vf2[K, N, E, G](
-    BaseGraphSimFunc[K, N, E, G], SimFunc[Graph[K, N, E, G], GraphSim[K]]
+class VF2Base[K, N, E, G](
+    ABC, BaseGraphSimFunc[K, N, E, G], SimFunc[Graph[K, N, E, G], GraphSim[K]]
 ):
     """Compute subgraph isomorphisms between two graphs.
 
-    - Convert the input graphs to Rustworkx graphs.
     - Compute all possible subgraph isomorphisms between the two graphs.
     - For each isomorphism, compute the global similarity.
     - Return the isomorphism mapping with the highest similarity.
     """
 
-    id_order: bool = False
-    subgraph: bool = True
-    induced: bool = False
-    call_limit: int | None = None
     max_iterations: int = 0
+    maximum_common_subgraph: bool = True
+
+    @abstractmethod
+    def node_mappings(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+    ) -> list[frozendict[K, K]]: ...
 
     @override
     def __call__(
@@ -39,6 +44,77 @@ class vf2[K, N, E, G](
         x: Graph[K, N, E, G],
         y: Graph[K, N, E, G],
     ) -> GraphSim[K]:
+        node_mappings: list[frozendict[K, K]] = []
+        next_permutations: list[Graph] = [y]
+
+        while next_permutations and not node_mappings:
+            current_permutations = next_permutations
+            next_permutations = []
+
+            for current_permutation in current_permutations:
+                node_mappings.extend(self.node_mappings(x, current_permutation))
+
+                if self.maximum_common_subgraph:
+                    # remove nodes from y to determine partial mappings
+                    next_permutations.extend(
+                        Graph(
+                            nodes=frozendict(
+                                (k, v)
+                                for k, v in current_permutation.nodes.items()
+                                if k != node_key
+                            ),
+                            edges=frozendict(
+                                (k, v)
+                                for k, v in current_permutation.edges.items()
+                                if v.source.key != node_key and v.target.key != node_key
+                            ),
+                            value=current_permutation.value,
+                        )
+                        for node_key in current_permutation.nodes.keys()
+                    )
+
+        graph_sims: list[GraphSim[K]] = []
+
+        for node_mapping in node_mappings:
+            edge_mapping = self.induced_edge_mapping(x, y, node_mapping)
+            node_pair_sims, edge_pair_sims = self.pair_similarities(
+                x, y, list(node_mapping.items()), list(edge_mapping.items())
+            )
+            graph_sims.append(
+                self.similarity(
+                    x,
+                    y,
+                    node_mapping,
+                    edge_mapping,
+                    node_pair_sims,
+                    edge_pair_sims,
+                )
+            )
+
+        return max(
+            graph_sims,
+            key=lambda sim: sim.value,
+            default=GraphSim(
+                0.0,
+                frozendict(),
+                frozendict(),
+                frozendict(),
+                frozendict(),
+            ),
+        )
+
+
+@dataclass(slots=True)
+class vf2_rustworkx[K, N, E, G](VF2Base):
+    id_order: bool = False
+    induced: bool = False
+    call_limit: int | None = None
+
+    def node_mappings(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+    ) -> list[frozendict[K, K]]:
         if len(y.nodes) + len(y.edges) > len(x.nodes) + len(x.edges):
             larger_graph, larger_graph_lookup = to_rustworkx_with_lookup(y)
             smaller_graph, smaller_graph_lookup = to_rustworkx_with_lookup(x)
@@ -59,14 +135,13 @@ class vf2[K, N, E, G](
             smaller_graph,
             node_matcher=node_matcher,
             edge_matcher=edge_matcher,
+            subgraph=True,
             id_order=self.id_order,
-            subgraph=self.subgraph,
             induced=self.induced,
             call_limit=self.call_limit,
         )
 
         node_mappings: list[frozendict[K, K]] = []
-        graph_sims: list[GraphSim[K]] = []
 
         for idx in itertools.count():
             if self.max_iterations > 0 and idx >= self.max_iterations:
@@ -98,30 +173,63 @@ class vf2[K, N, E, G](
             except StopIteration:
                 break
 
-        for node_mapping in node_mappings:
-            edge_mapping = self.induced_edge_mapping(x, y, node_mapping)
-            node_pair_sims, edge_pair_sims = self.pair_similarities(
-                x, y, list(node_mapping.items()), list(edge_mapping.items())
-            )
-            graph_sims.append(
-                self.similarity(
-                    x,
-                    y,
-                    node_mapping,
-                    edge_mapping,
-                    node_pair_sims,
-                    edge_pair_sims,
-                )
-            )
+        return node_mappings
 
-        return max(
-            graph_sims,
-            key=lambda sim: sim.value,
-            default=GraphSim(
-                0.0,
-                frozendict(),
-                frozendict(),
-                frozendict(),
-                frozendict(),
-            ),
+
+@dataclass(slots=True)
+class vf2_networkx[K, N, E, G](VF2Base):
+    def node_mappings(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+    ) -> list[frozendict[K, K]]:
+        if len(y.nodes) + len(y.edges) > len(x.nodes) + len(x.edges):
+            larger_graph = to_networkx(y)
+            smaller_graph = to_networkx(x)
+            node_matcher = reverse_positional(self.node_matcher)
+            edge_matcher = reverse_positional(self.edge_matcher)
+        else:
+            larger_graph = to_networkx(x)
+            smaller_graph = to_networkx(y)
+            node_matcher = self.node_matcher
+            edge_matcher = self.edge_matcher
+
+        # `first` must be the larger graph and `second` the smaller one.
+        graph_matcher = DiGraphMatcher(
+            larger_graph,
+            smaller_graph,
+            node_match=lambda x, y: node_matcher(x["value"], y["value"]),
+            edge_match=lambda x, y: edge_matcher(x["value"], y["value"]),
         )
+
+        mappings_iter = graph_matcher.subgraph_isomorphisms_iter()
+        node_mappings: list[frozendict[K, K]] = []
+
+        for idx in itertools.count():
+            if self.max_iterations > 0 and idx >= self.max_iterations:
+                break
+
+            try:
+                if len(y.nodes) + len(y.edges) > len(x.nodes) + len(x.edges):
+                    # y -> x (as needed)
+                    node_mappings.append(
+                        frozendict(
+                            (larger_idx, smaller_idx)
+                            for larger_idx, smaller_idx in next(mappings_iter).items()
+                        )
+                    )
+                else:
+                    # x ->  y (needs to be inverted)
+                    node_mappings.append(
+                        frozendict(
+                            (smaller_idx, larger_idx)
+                            for larger_idx, smaller_idx in next(mappings_iter).items()
+                        )
+                    )
+            except StopIteration:
+                break
+
+        return node_mappings
+
+
+vf2 = vf2_rustworkx

cbrkit-0.26.1/src/cbrkit/sim/graphs/precompute.py

@@ -1,56 +0,0 @@
-import itertools
-from collections.abc import Sequence
-from dataclasses import dataclass
-
-from ...model.graph import (
-    Edge,
-    Graph,
-    Node,
-)
-from ...typing import BatchSimFunc
-from .common import BaseGraphSimFunc, SemanticEdgeSim
-
-
-@dataclass(slots=True)
-class precompute[K, N, E, G](
-    BaseGraphSimFunc[K, N, E, G], BatchSimFunc[Graph[K, N, E, G], float]
-):
-    precompute_nodes: bool = True
-    precompute_edges: bool = True
-
-    def __call__(
-        self, batches: Sequence[tuple[Graph[K, N, E, G], Graph[K, N, E, G]]]
-    ) -> list[float]:
-        if self.precompute_nodes:
-            node_pairs: list[tuple[Node[K, N], Node[K, N]]] = []
-
-            for x, y in batches:
-                node_pairs.extend(
-                    (x_node, y_node)
-                    for x_node, y_node in itertools.product(
-                        x.nodes.values(), y.nodes.values()
-                    )
-                    if self.node_matcher(x_node.value, y_node.value)
-                )
-
-            self.batch_node_sim_func(node_pairs)
-
-        if self.precompute_edges and not isinstance(
-            self.batch_edge_sim_func, SemanticEdgeSim
-        ):
-            edge_pairs: list[tuple[Edge[K, N, E], Edge[K, N, E]]] = []
-
-            for x, y in batches:
-                edge_pairs.extend(
-                    (x_edge, y_edge)
-                    for x_edge, y_edge in itertools.product(
-                        x.edges.values(), y.edges.values()
-                    )
-                    if self.edge_matcher(x_edge.value, y_edge.value)
-                    and self.node_matcher(x_edge.source.value, y_edge.source.value)
-                    and self.node_matcher(x_edge.target.value, y_edge.target.value)
-                )
-
-            self.batch_edge_sim_func(edge_pairs)
-
-        return [1.0] * len(batches)

cbrkit-0.26.1/src/cbrkit/sim/graphs/qap.py

@@ -1,118 +0,0 @@
-import itertools
-from dataclasses import dataclass
-
-import numpy as np
-from frozendict import frozendict
-from scipy.optimize import quadratic_assignment
-
-from ...helpers import get_logger
-from ...model.graph import (
-    Graph,
-)
-from ...typing import SimFunc
-from .common import BaseGraphSimFunc, GraphSim
-
-logger = get_logger(__name__)
-
-__all__ = ["qap"]
-
-
-# https://jack.valmadre.net/notes/2020/12/08/non-perfect-linear-assignment/
-@dataclass(slots=True)
-class qap[K, N, E, G](
-    BaseGraphSimFunc[K, N, E, G], SimFunc[Graph[K, N, E, G], GraphSim[K]]
-):
-    """Quadratic Assignment Problem (QAP) solver for graph similarity
-
-    Currently not functional, the generated mappings are not correct.
-    """
-
-    def __call__(
-        self,
-        x: Graph[K, N, E, G],
-        y: Graph[K, N, E, G],
-    ) -> GraphSim[K]:
-        node_pair_sims, edge_pair_sims = self.pair_similarities(x, y)
-
-        n = len(y.nodes)
-        m = len(x.nodes)
-        dim = n + m
-        a = np.zeros((dim, dim), dtype=float)
-        b = np.zeros((dim, dim), dtype=float)
-
-        y2idx = {k: i for i, k in enumerate(y.nodes)}
-        x2idx = {k: i for i, k in enumerate(x.nodes)}
-        idx2y = {i: k for k, i in y2idx.items()}
-        idx2x = {i: k for k, i in x2idx.items()}
-
-        # put 1 on every real-node loop of a
-        # encode substitution / deletion cost on the corresponding loop of b
-        for i in idx2y.keys():
-            a[i, i] = 1.0  # selector
-            b[m + i, m + i] = 1.0  # deletion
-
-        for j in idx2x.keys():
-            b[j, j] = 1.0  # selector
-            a[n + j, n + j] = 1.0  # insertion
-
-        # substitution cost (real-real loops)
-        for (y_key, i), (x_key, j) in itertools.product(y2idx.items(), x2idx.items()):
-            b[i, j] = (
-                1 - node_pair_sims[(y_key, x_key)]
-                if (y_key, x_key) in node_pair_sims
-                else 1e9
-            )
-
-        # real edge in y, deletion cost when mapped to two dummies
-        for e in y.edges.values():
-            i, j = y2idx[e.source.key], y2idx[e.target.key]
-            b[m + i, m + j] = 1
-            b[m + j, m + i] = 1
-
-        # real edge in x, insertion cost when mapped from two dummies
-        for e in x.edges.values():
-            i, j = x2idx[e.source.key], x2idx[e.target.key]
-            a[n + i, n + j] = 1
-            a[n + j, n + i] = 1
-
-        # real-real pairs, substitution cost
-        for y_edge, x_edge in itertools.product(y.edges.values(), x.edges.values()):
-            i, j = x2idx[x_edge.source.key], x2idx[x_edge.target.key]
-            b[i, j] = (
-                1 - edge_pair_sims[(y_edge.key, x_edge.key)]
-                if (y_edge.key, x_edge.key) in edge_pair_sims
-                else 1e9
-            )
-
-        try:
-            res = quadratic_assignment(a, b, method="faq")
-        except ValueError as e:
-            logger.warning(f"Failed to compute QAP mapping for two graphs: {e}")
-
-            return GraphSim(
-                0.0,
-                frozendict(),
-                frozendict(),
-                frozendict(),
-                frozendict(),
-            )
-
-        # only consider substitutions of real nodes
-        node_mapping = frozendict(
-            (idx2y[y_idx], idx2x[x_idx])
-            for y_idx, x_idx in enumerate(res.col_ind)
-            if y_idx < n
-            and x_idx < m
-            and (idx2y[y_idx], idx2x[x_idx]) in node_pair_sims
-        )
-
-        edge_mapping = self.induced_edge_mapping(x, y, node_mapping)
-
-        return self.similarity(
-            x,
-            y,
-            node_mapping,
-            edge_mapping,
-            node_pair_sims,
-            edge_pair_sims,
-        )