$\Delta$-Motif: Parallel Subgraph Isomorphism via Tabular Operations

TL;DR

$ ext{Delta-Motif}$ introduces a GPU-accelerated subgraph isomorphism algorithm that reformulates the problem as database operations, achieving significant speedups and enabling scalable quantum circuit analysis.

Contribution

It presents a novel graph-to-database transformation approach for subgraph isomorphism, leveraging relational primitives for parallel GPU execution and broad applicability.

Findings

Achieves up to 595x speedup over traditional algorithms.

Successfully applies to quantum circuit compilation.

Democratizes high-performance graph processing using database abstractions.

Abstract

Subgraph isomorphism is a fundamental problem in graph analysis that seeks to find all instances of a pattern graph within a larger data graph while preserving structural relationships. This NP-complete problem is central to domains such as biological network analysis, social network mining, and quantum circuit optimization. Traditional approaches rely on backtracking algorithms like VF2, which suffer from sequential bottlenecks that limit their ability to exploit modern parallel hardware. In this work, we introduce $\Delta$-Motif, a GPU-accelerated subgraph isomorphism algorithm that reformulates the task through the lens of database operations. Our key insight is to represent both data and pattern graphs in tabular form, turning subgraph isomorphism into database primitives including joins, sorts, merges, and filters. $\Delta$-Motif decomposes graphs into small building blocks called motifs and systematically combines them using scalable relational operations. By leveraging mature, optimized libraries from the NVIDIA RAPIDS ecosystem and Pandas framework, our solution achieves massive parallelism while remaining portable across systems supporting standard relational primitives. Benchmarks show that $\Delta$-Motif outperforms established algorithms like VF2, achieving speedups of up to $595\times$ on GPUs. We further demonstrate its impact by applying it to quantum circuit compilation, addressing a critical bottleneck in quantum computing and enabling scaling to near- and medium-term devices. Our approach democratizes high-performance graph processing by exposing it through familiar database abstractions, eliminating the need for low-level programming while delivering exceptional computational efficiency.

Tables

Table 1. Table 1. Data science relevant graphs used for benchmarking, all taken from the SuiteSparse Matrix Collection  ( undefaau, ) . ID denotes the SSMC identifier. All matrices are square and the dimension refers to both rows and columns. Non-zero entries refers to the total number of non-zero entries.

Name	ID	Dimension	Non-zero entries	Data type
enron	2444	69,244	276,143	binary
soc-Slashdot0902	2287	82,168	948,464	binary
smallword	2576	100,000	999,996	binary
coAuthorsCiteseer	2461	227,320	1,628,268	binary
citationCiteseer	2460	268,495	2,313,294	binary

Table 2. Table 2. Observed speedup ranges of Δ \Delta - Motif (GPU) over VF2 across pattern sizes and data graph configurations. For each configuration, we report the mean, minimum, and maximum speedups measured over all random seeds. GSI performance is discussed in the main text but omitted from this table, as results were unavailable for most problem sizes.

Data Graph		Pattern Graph Size
Type	Size	20			40			60			80			100
		min	mean	max	min	mean	max	min	mean	max	min	mean	max	min	mean	max
Heavy Hex	1990	0.64	2.96	7.84	1.61	12.78	151.11	1.85	14.05	210.91	1.83	15.62	179.33	2.48	13.03	160.35
	4485	2.76	10.09	22.58	5.70	35.76	238.03	6.84	42.43	294.80	9.95	49.53	269.72	9.18	42.36	415.20
Square Grid	1600	0.91	3.29	46.98	1.49	6.24	78.85	2.21	11.58	313.95	2.44	12.65	135.46	1.57	15.20	99.58
	3600	2.75	7.79	127.64	5.17	17.50	146.19	7.25	30.11	594.92	8.32	36.50	306.00	8.15	53.43	269.03

Full text

1. Introduction

Graphs have emerged as one of the most flexible and powerful data structures to represent complex relationships, leading to their ubiquitous presence across various computational domains. From modeling molecular interactions in bioinformatics (undef, ) and tracking social connections in network analysis (undefa, ) to mapping dependencies in cybersecurity systems (undefb, ), graphs provide an intuitive and mathematically rigorous framework for capturing the intricate patterns that define real-world systems.

Central to many graph-based applications is the subgraph isomorphism problem, which seeks to find all instances of a pattern graph within a larger data graph while preserving structural relationships. This problem is known to be NP-complete (undefc, ), yet it remains essential for tasks ranging from motif discovery in biological networks (undefd, ), social networks analysis (undefe, ), data mining (undeff, ), drug discovery(undefg, ) and circuit mapping in quantum devices (undefh, ). The ubiquity of its application to various use cases can create critical bottlenecks in compute and workload execution. Driving efficiencies for subgraph isomorphism will alleviate key barriers to the incorporation of emerging technologies like quantum computing into high-performance computing environments, and thereby its adoption for meaningful impact.

Traditional approaches to subgraph isomorphism, such as VF2 (undefi, ), VF2++ (undefj, ), and VF3 (undefk, ), rely on backtracking algorithms with a largely DFS-like traversal pattern. This search strategy makes these methods inherently sequential and difficult to parallelize effectively. Code specialization techniques have been proposed to mitigate these limitations (undefl, ), and a range of systems have explored distributed execution, accelerator-based designs, and commercial data-processing frameworks such as Hadoop (undefm, ), Cassandra (undefn, ), and Spark (undefo, ). Subgraph isomorphism workloads also vary widely in structure, including weighted or unweighted graphs, small structured patterns, large random patterns, and data graphs with diverse connectivity properties. As a result, no single algorithm is optimal across all settings, and existing work spans a broad set of complementary approaches. We discuss these trade-offs in more detail in Sec. 2.

A key motivation for this work is the use of subgraph isomorphism in quantum circuit compilation. Recent work by Nation et al. (undefh, ) applied a Rust-based implementation of VF2 (undefp, ) in this setting, illustrating both the practicality and limitations of classical backtracking approaches. In our own evaluation, we found that such algorithms limit effective utilization of hundreds of CPU cores and modern GPU architectures. In quantum computing, the pattern graphs of interest are relatively large, typically on the order of dozens to around one hundred vertices in state-of-the-art workloads. As devices continue to scale, even larger patterns are becoming relevant. At these sizes, many existing parallel subgraph isomorphism algorithms perform poorly or fail to scale effectively, whereas our algorithm remains efficient.

To overcome the sequential bottlenecks and limited parallelism of existing subgraph isomorphism enumeration, we developed a novel data-science centric solution that reformulates of the problem as a series of tabular data operations. By representing both data and pattern graphs in tabular format, subgraph isomorphism is transformed into fundamental database operations such as joins, sorts, merges and filters. This formulation transforms a traditionally graph-theoretic problem into one that naturally aligns with modern data-processing ecosystems.

A key strength of this approach is its portability across tabular data systems. The algorithm can be implemented on any database platform supporting standard relational operations, ranging from traditional databases to in-memory frameworks such as Pandas (undefq, ). This portability enables seamless acceleration using the NVIDIA RAPIDS ecosystem  (undefr, ; undefs, ; undeft, ) for GPU acceleration, while maintaining full compatibility with CPU-based execution.

Although the aforementioned operations are conceptually straightforward and also fundamental to database systems, achieving high performance in practice is nontrivial. For this reason, we chose to build upon the RAPIDS library, ensuring that future performance improvements to the library will directly benefit our algorithm’s performance while remaining deployable on commodity hardware using open-source software. As a result, the algorithm inherits massive parallelism from existing optimized libraries, delivering strong GPU performance and making high-performance graph processing accessible through familiar data science tools and abstractions, without requiring specialized low-level programming.

1.1. Contributions

We organize our contributions into four key areas. First, we introduce a novel algorithm for subgraph isomorphism enumeration based on motif-driven decomposition. Instead of matching full subgraphs directly, $\Delta$-Motif decomposes graphs into reusable building blocks, called motifs, such as paths and small cycles, and reconstructs complete matches by systematically combining these units using relational operations. While prior work has explored motif-based decomposition, our approach differs fundamentally by formulating subgraph isomorphism as a sequence of join-and-filter operations over tabular data.

Second, through extensive benchmarking, we show that $\Delta$-Motif significantly outperforms well-established algorithms such as VF2 and state-of-the-art GPU implementations including GSI across a wide range of data and pattern graph sizes. On GPU architectures, $\Delta$-Motif achieves speedups of up to $595\times$, with particularly strong performance on regular graph topologies with predictable connectivity, including those motivated by quantum-hardware architectures. We further demonstrate that careful motif selection can substantially improve performance, yielding up to $10\times$ speedups over naive strategies.

Third, we evaluate $\Delta$-Motif on two complementary benchmark suites. We first study real-world network datasets using small pattern graphs, such as triangle enumeration, which represent common graph analytics workloads. We then conduct extensive experiments on graph workloads motivated by quantum computing, where large pattern graphs with dozens to hundreds of vertices must be matched against structured data graphs. Together, these benchmarks demonstrate that $\Delta$-Motif performs robustly across both small-pattern and large-pattern regimes, achieving strong and consistent performance improvements over existing methods.

Fourth, we that $\Delta$-Motif achieves high performance on both CPU and GPU using commodity hardware and open-source software. By relying exclusively on standard data science and database abstractions, our algorithm does not require custom kernels and extensive low-level hardware tuning as compared to many existing GPU-based solutions (discussed in more detail in Sec. 2).

2. Related Work

The VF2 algorithm (undefi, ) uses a depth-first backtracking strategy to incrementally construct partial isomorphisms while applying pruning rules to maintain consistency. It is specifically designed for memory efficiency and performs well on relatively small or dense graphs. Similar specialized approaches include AutoMine (undefu, ), which generates optimized code for specific graph patterns, and Dryadic (undefl, ), which uses compilation-based techniques to accelerate pattern-specific subgraph matching. More broadly, a large body of CPU-oriented work explores pruning strategies, memory reduction, and algorithmic refinements (undefv, ; undefw, ; undefx, ; undefy, ). While effective in many settings, these approaches offer limited opportunities for scalable parallelism.

Although VF2 performs well on relatively small graphs, its performance degrades as the size and density of the target graph increase. Several variants have attempted to address these limitations: VF2++ (undefj, ), VF3 (undefz, ), and VF3L (undefk, ) improve search efficiency through more aggressive pruning strategies, while VF3P (undefaa, ) introduces CPU-based parallelization. VF2-PS (undefab, ) extends the VF2 algorithm to work in Arachne (undefac, ) and using the Chapel programming language. .Although these extensions can accelerate the discovery of individual solutions, they do not fundamentally address the limitations of the tree-based search structure. As a result, these approaches offer limited scalability on modern hardware architectures designed to exploit massive parallelism, particularly GPUs.

Recent work has explored GPU acceleration for subgraph isomorphism (undefad, ; undefae, ; undefaf, ; undefag, ; undefah, ; undefai, ; undefae, ; undefaj, ; undefak, ). These methods achieve performance improvements through techniques such as breadth-first expansion, vertex-centric execution, and specialized data structures. However, most rely on custom GPU kernels, hardware-specific optimizations, and extensive low-level tuning that creates significant barriers to adoption. GAMMA (undefaj, ), for example, uses an out-of-core design spanning host and device memory to support larger graphs, but incurs performance penalties due to frequent data movement over the PCIe interconnect. In contrast, Decomine (undefal, ) uses a compiler-based approach to generate pattern-specific code, avoiding custom kernels at the cost of reduced generality.

Complementary to accelerator-based approaches, the graph database community has explored scalability through indexing and multi-phase execution strategies. Indexing-based techniques (undefam, ; undefan, ) accelerate queries by decomposing subgraph isomorphism into indexing and verification phases, while BICE (undefao, ) separates preprocessing from enumeration to reduce redundant computation. Our algorithm also adopts a multi-phase structure, yet it differs in its data-centric formulation and execution model.

A complementary direction focuses on scalability through distributed and disk-based execution models (undefap, ; undefaq, ; undefn, ; undefm, ; undefo, ), often using bulk synchronous processing. While such systems can scale to large datasets, they typically incur higher runtime overheads due to I/O and communication costs, and therefore commonly target smaller pattern sizes.

Beyond these system-level approaches, our work also draws ideas from a different subfield in graph processing. The concept of motifs is well established in graph analytics to characterize recurrent structures in biological networks(undefar, ) and network classification tasks(undefas, ). However, prior work has primarily focused on motif discovery and counting, rather than using motifs as computational building blocks for solving subgraph isomorphism. EGSM (undefat, ) and ESCAPE (undefau, ) decompose matching tasks into smaller components, an idea related in spirit to our approach. However, these methods rely on specialized data structures and search strategies, whereas our algorithm formulates decomposition and recombination entirely through relational operations.

Several existing approaches employ join-based formulations, including DGSM (undefag, ) and FGSM (undefai, ). Lai et al. (undefav, ) propose a multi-join strategy that reduces intermediate results by filtering rows between joins. Although related in spirit, their approach assumes join-only execution, whereas our method introduces additional synchronization and filtering steps between joins to enforce structural constraints. Many GPU-based methods, including DGSM (undefag, ), EGSM (undefat, ), and cuTS (undefaf, ), further rely on specialized data structures to store intermediate results, increasing implementation complexity and reducing portability across evolving hardware platforms. In contrast, our algorithm represents both intermediate and final results using standard tabular data structures, benefiting directly from ongoing optimizations in data processing libraries while remaining accessible to practitioners familiar with standard data science tools. This data-centric formulation also naturally extends to distributed environments through existing frameworks that manage partitioning and communication without requiring specialized synchronization logic.

Finally, existing solutions target a wide range of pattern types, differing in size, structure, and associated properties, which makes direct comparisons difficult. For instance, many studies focus on enumerating relatively small patterns, often fewer than a dozen vertices, even when operating on large data graphs. For example, EGSM (undefat, ) reports results for patterns of up to 16 vertices, while cuTS (undefaf, ) and ESCAPE (undefau, ) evaluate patterns of up to 5 vertices, and other work emphasizes small clique enumeration (undefah, ). At the same time, algorithm performance is strongly influenced by properties of the data graph itself. For instance, cuTS (undefaf, ) targets sparse networks such as road graphs, whereas SGSI (undefak, ) operates on weighted vertices and edges, introducing different computational trade-offs compared to unweighted settings.

These differences highlight the need for a range of approaches tailored to different application requirements and usage patterns. While our algorithm might not be the most performant in all cases, it shows strong performance in many cases (including outperforming many of the state-of-the-art solutions). One of the big benefits of new algorithm is that it avoids custom kernels and specialized data structures by relying on open-source tabular data frameworks with well-defined APIs, prioritizing programmability, portability, and long-term maintainability while maintaining strong performance on modern parallel hardware.

2.1. Subgraph Isomorphism Enumeration in Quantum Circuit Compilation

As quantum hardware steadily advances, near-term processors have emerged as promising platforms for exploring algorithmic realizations to demonstrate quantum advantage (undefaw, ; undefax, ; undefay, ). However, these systems remain fundamentally constrained by imperfect control (undefaz, ; undefaaa, ; undefaab, ; undefaac, ), hardware variability (undefaad, ; undefaae, ), and short coherence times (undefaaf, ). Quantum circuit compilation plays a critical role in minimizing operational overhead and mitigating error accumulation to improve execution fidelity (undefaag, ). Given a quantum device and a quantum circuit, the compilation pipeline aims to realize the target algorithm with fewer operations and a shorter execution time, thereby reducing the impact of noise. These procedures collectively define the topology and operation count of the compiled circuit before execution on hardware.

Crucially, not all qubits (the information carriers in quantum computers) in a quantum processor offer the same operational quality (undefaz, ; undefaae, ). Due to the inherent fragility of quantum systems and the challenges associated with device calibration, processors often contain faulty or low-fidelity qubits and couplings. As a result, the choice of which subset of physical qubits to utilize for executing a compiled circuit can significantly influence the circuit’s overall computational fidelity. For the same circuit, different mappings of circuit logical qubits into hardware physical qubits, referred to as layouts, may yield significantly different execution outcomes (undefh, ; undefaah, ). This sensitivity to choice of layout has motivated the development of systematic layout selection methods, typically structured as a two-phase process: layout generation and score-based ranking. Layout generation explores search space of candidate mappings by enumerating subgraph isomorphisms between the circuit’s interaction graph and the hardware’s connectivity graph, after which valid layouts are evaluated using device-specific quality metrics to select the most promising one.

In addition to graph-theoretic methods, machine learning approaches have also been explored for layout selection. For example, Hartnett et al. (undefaah, ) proposed a learning-based model that ranks candidate layouts using device-specific calibration data. However, such approaches operate on precomputed candidate layouts and therefore do not address layout generation, the most computationally demanding stage of the problem.

In this work, we present an algorithm based on tabular operations motivated by graph workloads arising in quantum circuit compilation, where layout generation is formulated as a subgraph isomorphism enumeration problem. A distinctive characteristic of this domain is that the pattern graphs are relatively large, typically on the order of dozens to around one hundred vertices in state-of-the-art workloads. This contrasts with many traditional subgraph matching workloads that emphasize small pattern graphs (with 10 or fewer vertices) embedded within very large data graphs; however, large pattern graphs can still induce substantial search spaces and many valid embeddings, making enumeration computationally challenging. As quantum devices continue to scale and incorporate additional qubits, even larger interaction patterns are expected to become relevant, motivating algorithms capable of efficiently handling larger pattern graphs while exploiting the structured connectivity commonly observed in quantum hardware topologies.

Moreover, motivated by the observation that data graphs representing the physical qubit connectivity in quantum hardware typically remain static over time, we propose that a significant portion of our pipeline can be precomputed and cached. This use-case-specific feature enables the reuse of intermediate results across multiple compilation runs, delivering even more aggressive speedups in practice when precomputation costs are excluded. Our approach not only enables more powerful quantum circuit compilation, but also facilitates deeper integration with classical HPC systems, paving the way for delivering tangible value in the emerging era of near-term quantum utility.

3. Data-Centric Subgraph Isomorphism Algorithm

In this section, we introduce a data-science-inspired method for solving the subgraph isomorphism problem. Instead of exhaustively searching for full pattern matches in the data graph via node-by-node traversal, we adopt a modular strategy based on motif decomposition. We call this approach $\Delta$-Motif, reflecting the decomposition of pattern graphs into smaller components. In Section 4, we draw an analogy between $\Delta$-Motif and the popular $\Delta$-Stepping algorithm for single-source shortest path (SSSP) problems (undefaai, ), highlighting a similar trade-off between additional work and improved parallelism. The details of this analogy become clearer after introducing the algorithm and its performance characteristics.

3.1. Preliminaries

Subgraph Isomorphism

We formally define a graph as a tuple $G=(V,E)$, where $V$ is a finite set of vertices and $E\subseteq V\times V$ is the set of undirected edges. Let the data graph be denoted as $G_{d}=(V_{d},E_{d})$ and the pattern graph as $G_{p}=(V_{p},E_{p})$. We say that $G_{p}$ is isomorphic to a subgraph of $G_{d}$ if there exists an injective mapping $f:V_{p}-V_{d}$ such that $(u,v)\in E_{p}\iff(f(u),f(v))\in E_{d}$. The subgraph isomorphism enumeration problem is to find all such mappings $f$ from $G_{p}$ into vertex-induced subgraphs of $G_{d}$ that preserve adjacency as defined above. Throughout this work, we assume all graphs are unlabeled, undirected and connected.

Motifs

Motifs are size-limited, well-defined subgraphs that capture local structural patterns within a graph. Common examples include linear paths (e.g., $a-b-c$), triangles ($a-b-c-a$), and other frequent occurring configurations such as squares, stars, or short cycles. In this work, we pre-define a set of motifs $\{M_{0},M_{1},\dots,M_{k}\}$, where each $M_{i}=(V_{i},E_{i})$ is a small, connected subgraph of the data graph. Fig. 1 illustrates the lattice structures used as data graphs in our benchmarks, together with the representative motifs derived from them. We have attempted to keep the naming of the motifs fairly simple: $M_{i}$ denotes a path of $i$ vertices, while additional suffixes (e.g., “-O” for cycles or “-1” for one branch) indicate common variations.

These motifs serve as the building blocks for decomposing both data and pattern graphs into sequences of motif instances, which can then be incrementally joined to reconstruct larger subgraph matches. As we show in later sections, the choice and ordering of motif set directly influence performance. Selecting motifs requires balancing expressiveness with computational cost, and is informed by the structural characteristics of both the data and pattern graphs.

We denote the set of all embeddings of a motif $M_{i}$ in the data graph by $Res(M_{i})$. Each element in $Res(M_{i})$ is a tuple of vertex indices that together form a subgraph isomorphic to $M_{i}$. These embeddings are stored in tabular form, where each row corresponds to a single match and each column to a vertex position in the motif template. This tabular format allows subsequent processing, such as joining embeddings and enforcing constraints, to be performed using scalable dataframe operations.

3.2. The $\Delta$-Motif Approach

To motivate our approach, we begin with a simple example. Consider a data graph $G_{d}$ with 7 nodes, shown in Fig. 2(a), and a pattern graph $G_{p}$ defined as a 6-node undirected cycle shown in Fig. 2(b). Rather than trying to match the entire cycle directly in the $G_{d}$, we firstly decompose $G_{p}$ into a set of smaller, overlapping motifs, $\mathcal{M}=\{M_{0},\dots,M_{i}\}$. Each motif captures a localized structure that can be matched independently. For each $M_{i}$, we compute the set of all isomorphic embeddings in the data graph, denoted $Res(M_{i})$. These partial embeddings are then incrementally combined through join operations, followed by a filter step to ensure that only valid matches of the full pattern are retained. The final result, $Res(G_{p})$, contains all complete isomorphisms of $G_{p}$ within $G_{d}$. This divide-and-conquer strategy is conceptually simple, yet highly effective. By reducing the matching task to individual motif-level computations, we achieve computational efficiency through parallelization. Furthermore, reusing motif embeddings avoids redundant searches that often appears in the tree-search and prune approach.

To make this process concrete, we now present a step-by-step example of finding all subgraph isomorphisms. As a first step, we select a set of motifs to be used to decompose $G_{p}$. The number of unique motifs can explode with increasing graph size, and thus creating a list of all possible motifs is infeasible. Thus, we limit ourselves to a small subset of these. The motif set $\mathcal{M}$ can be predefined or adaptively selected based on the characteristics of the data graph. The efficiency of the overall decomposition process depends heavily on this choice. Larger motifs reduce the number of necessary decompositions, but are more expensive to compute and store. Whereas smaller motifs offer greater flexibility and lower overhead. We discuss detailed motif selection strategies in later sections, and for now, we focus on demonstrating the workflow.

In this example, we only use two motifs: $M_{2}$, a simple 2-node edge, and $M_{4}$. The embeddings of $M_{2}$, $Res(M_{2})$, are always available since they can be obtained by enumerating all edges in $G_{d}$, and hence serve as a default primitive in our method. Building on these primitives, $Res(M_{4})$ can be computed by calling the complete workflow of our solver, which constructs larger motif embeddings from smaller ones like $Res(M_{2})$, we omit the details of this computation until the underlying components are fully introduced and discussed in the pseudo-code, thus we assume that both $Res(M_{2})$ and $Res(M_{4})$ have been computed and stored in tabular form like a dataframe structure, as illustrated in Fig. 2(c). Each row in the dataframe corresponds to a matched subgraph in the data graph, and each column represents the vertex indices assigned to the corresponding positions in the motif.

With the motif embeddings prepared, the next step is to decompose the pattern graph using these motifs as templates. There are many valid ways to decompose a pattern graph - we only need to find one. A common strategy is to prioritize larger motifs, as they tend to reduce the number of decomposition steps. Additionally, we require that adjacent components share overlapping vertices, which will later serve as join key constraints during the join phase, discussed in details later.

In Fig. 2(d), we illustrate two valid decompositions using only $M_{4}$, with each slice $S_{i}$ highlighted in a different color. For this example, we choose one such decomposition: $S_{0}:v_{2}-v_{3}-v_{4}-v_{5}$ and $S_{1}:v_{5}-v_{0}-v_{1}-v_{2}$. Here, $S_{i}$ denotes the $i$-th graph slice of the decomposition, and the two slices share overlapping vertices at $v_{2}$ and $v_{5}$. To clarify the terminology, $M_{4}$ represents the generic motif structure used as a reusable matching template, while each $S_{i}$ is a concrete subgraph of $G_{p}$ with fixed vertex assignments. Since we use $M_{4}$ for decomposition, both $S_{0}$ and $S_{1}$ are instances of $Res(M_{4})$, and together they reconstruct the full cycle of $G_{p}$.

Our decomposition records the overlapping vertices between slices, which later serve as constraints in the join phase. In this example, the overlaps occur at $v_{2}$ and $v_{5}$, corresponding to the constraints $S_{0}[0]=S_{1}[3]$ and $S_{0}[3]=S_{1}[0]$. We now proceed to join the motif embeddings corresponding to the slices. For clarity, we denote the two dataframes as $Res(M_{4})_{\text{L}}$ and $Res(M_{4})_{\text{R}}$, representing the left and right sides of the join operation. Based on the overlapping nodes identified during decomposition, the join constraints are defined as $Res(M_{4})_{\text{L}}[0]==Res(M_{4})_{\text{R}}[3]$ and $Res(M_{4})_{\text{L}}[3]==Res(M_{4})_{\text{R}}[0]$, where the bracket notation refers to entire columns of vertex assignments at the respective motif embeddings. These constraints are used as join keys in the operation, which is efficiently implemented in standard dataframe libraries and relational database systems. The join step eliminates invalid combinations and retains only those pairs of embeddings that satisfy the required boundary conditions. Fig. 2(e) illustrates the join operation and its output to clarify the overall process.

Although the join operation enforces the specified boundary constraints between motif embeddings, it may still produce combinations with unintended vertex overlaps. These arise when two embeddings share additional vertices beyond the expected overlaps, violating the one-to-one vertex mapping required for valid subgraph isomorphism. To address this, we introduce a filter step that removes such invalid combinations. Fig. 2(f) illustrates an example of this issue. In general, the number of duplicated vertices in each joined row should exactly match the number of join constraints. Any row containing additional duplicates is deemed invalid and discarded. This is similar to the pruning phase of a tree-search.

By applying this join-and-filter process, we ensure that only valid subgraph isomorphisms are retained in the final result. Algorithm 1 outlines the procedure at a high-level. In the following subsections, we formalize this methodology and show how it enables a highly parallelizable, data-centric algorithm built entirely on open-source, commodity data science tools, without requiring any custom GPU kernels. Nevertheless, the approach delivers strong performance and scalability.

3.3. Pattern Graph Decomposition Using Motifs

Recall that in the previous subsection, we showed how a pattern graph can be decomposed into smaller overlapping components, each corresponding to a motif. In that example, the two motifs were sufficient to cover the entire pattern graph. In this section, we extend that concept and show that any pattern graph can be decomposed using a broader set of motifs.

In principle, many motifs could be used for decomposing the graph; we typically restrict ourselves to a small, carefully-chosen family that balances coverage and computational cost. The choice of motifs has a significant impact on the performance of the algorithm. Larger motifs do not necessarily guarantee faster execution, as their embeddings $Res(M)$ often result in more expensive join operations. Including more motifs in the set also increases the upfront preparation time. In section 6.3, we discuss how to select an appropriate motif set based on the characteristics of both the data and pattern graphs, and support these design choices with empirical results.

Given a defined set of motifs $\mathcal{M}$, we now turn to decomposing the pattern graph $G_{p}$ into smaller slices. At each iteration, we traverse the chosen motif set in descending order of size, favoring larger motifs to reduce the number of decomposition steps. For each motif in the set, we invoke a subgraph isomorphism solver, such as VF2, to find a valid matching slice $S_{i}$. If a match is found, it becomes the next slice in the decomposition; otherwise, we continue to the next motif in the list. VF2 is chosen here because it quickly returns a single match, which suits our needs for this iterative, one-slice-at-a-time decomposition process.

While this may seem counterintuitive as we replace one subgraph isomorphism problem with another, we highlight the following: 1) instead of performing subgraph isomorphism on the data graph, we apply it to the typically much smaller pattern graph, 2) the motifs we seek are typically orders of magnitude smaller than both the data and pattern graph, and 3) in our motif decomposition, we only require finding a single match of the motif in the pattern, allows us to terminate the search early rather than exhaustively enumerating all possible matches. Under these conditions, the tree-search based algorithm is actually more suitable and efficient for this task. Lastly, the motif decomposition searches for a decomposition rather than the ideal decomposition.

Once a slice $S_{i}$ is identified, the algorithm inspects all vertices in $S_{i}$ to determine which have outgoing edges that remain uncovered in the current pattern graph. These vertices are designated as boundary nodes. Boundary nodes serve as connection points for subsequent slices. For example, in Section 3.2, vertices $v_{2}$ and $v_{5}$ from $S_{0}$ play this role. The non-boundary nodes from $S_{i}$ are removed from the pattern graph to form a reduced graph for the next iteration, while the boundary nodes are retained to ensure overlap with subsequent matches. This procedure is repeated in the following iterations. Each new slice is matched using the reduced pattern graph, and its overlapping vertices with the union of previously selected slices are recorded. These overlapping vertices define structural dependencies across slices and are stored as join constraints. These constraints will later be used in the join step to reassemble the full pattern structure.

As a result of the decomposition process, we obtain a sequence of slices $S_{0},S_{1},\dots,S_{n}$ along with their corresponding list of motifs. This sequence determines the order in which the motifs appear within the pattern graph, and consequently, the order in which the associated $Res(M)$ dataframes are joined during reconstruction.

In practice, we observed that the decomposition step is computationally inexpensive and contributes only a negligible portion to the overall runtime. However, we believe there is substantial room for further optimization in motif selection, motif ordering, and the decomposition strategy, as these factors can directly impact the efficiency of subsequent join-and–filter operations. While this is not in the scope of this paper, we believe they represent promising opportunities for future research.

3.4. From a Single Motif to Computing Embeddings of Motif Sequences

In the above, we decomposed the pattern graphs into a sequence of motifs. In this subsection, we show how we can extract the embeddings of those motifs from the data graph and how we connect the results of multiple motif searches. As a simple case, searching for motif $M_{2}$ is equivalent to returning all edges of $G_{d}$ excluding self-loops $a-a$. Formally, $Res(M_{2})=E_{d}\setminus E_{self}$, where $E_{self}$ is the set of self-loops.

To compute embeddings of larger motifs, we apply a sequence of join-and-filter operations using an algorithm described in Algorithm 1. For example, consider the motif $M_{3}$, defined as a simple path: $a-b-c$ where $a\neq b\neq c$. Its embeddings, denoted $Res(M_{3})$, can be computed by inner-joining two instances of $Res(M_{2})$ on the shared node $b$. This can be written as: $Res(M_{3})=\text{L}\bowtie_{\text{L}[1]==\text{R}[0]}\text{R}$, where both L and R refer to the same table $Res(M_{2})$. The join captures all three-node paths, and is followed by a filtering step to eliminate invalid embeddings. For example, since both edges $a-b$ and $b-a$ exist in the undirected data graph, the resulting table may incorrectly include the cyclic pattern $a-b-a$. The filter removes such entries and ensures that all three vertices in each triplet are distinct. This entire process can be carried out in a single call to our motif solver. The resulting set $Res(M_{3})$ is stored in a dataframe format.

Similarly, embeddings of larger motifs can be computed recursively. For example, $Res(M_{4})$ can be built by joining $Res(M_{3})$ with $Res(M_{2})$ on the last and first vertex: $Res(M_{4})=\text{L}\bowtie_{\text{L}[2]==\text{R}[0]}\text{R}$, where $\text{L}=Res(M_{3})$ and $\text{R}=Res(M_{2})$, followed by filtering. The join order can also be reversed, using $(M_{2},M_{3})$ instead of $(M_{3},M_{2})$. This pattern generalizes naturally. For example, to construct $Res(M_{5})$, one could join $(M_{3},M_{3})$ or $(M_{4},M_{2})$. The simplicity of this approach to motif construction, as shown in Algorithm  2, is what makes our framework powerful and flexible. Its benefits will become even more apparent in the following subsections.

3.5. Performance Increase from Larger Motifs

The use of larger motifs for decomposing the pattern graph has several benefits: 1) fewer motifs are needed for the decomposition, hence fewer join-and-filter , which can be substantially fewer than the branching levels explored in a VF2 tree search, 2) larger motifs can increase parallelism in the data pre-processing phase, and 3) larger motifs enable early-stage pruning of invalid solutions, which also takes place during the pre-processing phase. In our performance analysis, we show that using larger motifs will outperform the $M_{2}$-only case.

4. Analog To Tree Search And Prune

Now that we have presented our new join-based algorithm for subgraph isomorphism, we can draw a parallel to the traditional tree-search and prune-based approaches. While not apparent at first glance, these algorithms share quite a few algorithmic features but also trade off a few. The literature is full of algorithms that alternate between BFS and DFS for conducting the pattern search.

4.1. Parallelism Vs. Storage

Recall that most tree-search and prune-based solutions rely on recursion. While some parallelism is possible, it is mostly attainable by creating an ordered set of vertices that represent the first few levels of the tree search (e.g., one to three) and parallelizing across those ordered elements – this one example in which a BFS is conducted at the beginning to generate initial starting conditions and is then followed by DFS operations that focus on finding the remaining pattern. Extending parallelism beyond these initial levels can present several challenges: workload imbalance, larger memory footprint for storing starting points (similar to generating $Res(M_{3})$), and most critically, synchronization overhead as parallel threads must coordinate access to shared data structures. For these reasons, the tree search and prune algorithms face inherent limitations in the degree of parallelization that they can achieve. And this also explains why some algorithms are limited to finding patterns with fewer than 10 vertices and edges.

In contrast, most phases of $\Delta$-Motif are inherently parallel because each row in our dataframe represents an independent candidate. The algorithm applies the same operations uniformly across all rows, enabling massive parallelization where thousands of candidate mappings can be processed simultaneously – similar to the BFS operation. This parallelism comes at a cost: our new algorithm has an increased memory footprint. The increased memory requirements stem from two main factors: 1) holding intermediate data generated during join operations before key constraints are applied to prune invalid matches and 2) storing complete tables of intermediate solutions after each join-and-filter iteration.

4.2. $M_{2}$ and Its Analogy to Parallel Tree-Search

Consider the case where the pattern graph is decomposed only with the $M_{2}$ motif. In this setup, the number of steps in $\Delta$-Motif matches the branching levels explored in a VF2 tree search. The difference is that VF2 moves forward one branch at a time in sequence, while $\Delta$-Motif processes all branches at a given level in parallel (similar to a BFS traversal). For example, the first $M_{2}$ expansion enumerates all edges, the next expands them into all possible 3-hop paths, then into 4-hop paths, and so on. This mirrors the depth expansion of VF2 but instead of walking the tree branch by branch, $\Delta$-Motif resolves each level through joins and filters that run simultaneously. This approach may require more intermediate storage, but the payoff is the ability to handle entire layers of the search space at once, effectively trading storage for scalability and providing a parallel counterpart to VF2’s sequential tree-search-and-prune. The results presented in the following sections show that this trade-off yields significant performance gains.

The $M_{2}$-only case exhibits inefficiencies similar to tree-search approaches such as VF2, as it must still explore shorter paths of length 2, 3, and 4 while pruning non-relevant branches along the way. This recursion incurs significant overhead, and the same path may be traversed multiple times from different starting points. It also implies that we might pay the penalty of traversing the bad path multiple times. In contrast, using larger motif choices allows $\Delta$-Motif to operate on larger structural units, avoiding repeated traversal; invalid candidates are discarded during filtering rather than through recursive backtracking. Additionally, the irregular branching patterns inherent in tree-search algorithms lead to frequent branch mispredictions, which have been shown to be costly in both sorting (undefaaj, ) and graph algorithms (undefaak, ). The irregular traversal patterns of VF2 exhibit similar challenges for modern processors.

4.3. $\Delta$-Motif and $\Delta$-Stepping

We now return to the analogy with the $\Delta$-Stepping algorithm for solving the SSSP problem. Although SSSP and subgraph isomorphism address different problems, both approaches expose additional parallelism by allowing extra work during execution. In $\Delta$-Stepping, the parameter $\Delta$ trades computational efficiency for parallelism by allowing vertices to be processed earlier at the cost of potentially revisiting them. Similarly, our $\Delta$-Motif exposes parallelism at multiple granularities: across multiple paths all within the same motif, across the entire join-and-filter operations, and across the preparation of all the motif embeddings in pre-processing computation. Together, these design choices enable $\Delta$-Motif to achieve strong performance on both CPUs and GPUs.

5. Experimental Setups

5.1. Software and Hardware Configurations

One of the goals of this work is to demonstrate that the subgraph isomorphism could be implemented using open-source and well-defined data-science frameworks and standard APIs, enabling execution on both CPU and GPU platforms without specialized kernels while maintaining high performance. Moreover, our implementation is designed to be flexible enough to run efficiently across hardware platforms.

CPU Implementation

Our CPU implementation leverages both Pandas (undefaal, ) and NumPy (undefaam, ), representing motif embeddings and candidate isomorphisms as Pandas DataFrames. We rely on Pandas’ efficient merge operations and NumPy’s vectorized filter capabilities for core processing. While these libraries do not use multi-threading by default, they achieve performance gains through Single Instruction Multiple Data (SIMD) execution (undefaan, ).

GPU Implementation

$\Delta$-Motif on the GPU is implemented using cuPy (undefr, ) and cuDF 25.6.0 (undefs, ), which serve as drop-in replacements for NumPy and Pandas, respectively. Due to strong interoperability across the NVIDIA RAPIDS ecosystem and adherence to Apache Arrow standards, our algorithm can transition between CPU and GPU execution with only minimal changes to Python import statements. While subgraph isomorphism is a graph problem, our implementation does not rely on cuGraph or NetworkX (undefaao, ). Instead, it directly operates on tabular data representations using cuDF and cuPy. We note that RAPIDS provides a rich suite of additional GPU-accelerated libraries, including cuML, cuGraph, and cuSpatial, that can be leveraged in broader workflows.

VF2 and rustworkx

We use the VF2 algorithm as our baseline, representing the broader class of tree-search-and-prune methods for subgraph isomorphism. Introduced over two decades ago (undefi, ), VF2 remains a widely used standard in both research and production, with mature implementations available in NetworkX (undefaao, ), the Boost Graph Library (undefaap, ), and rustworkx(undefp, ). For our experiments, we selected rustworkx, a high-performance Rust implementation that maintains a NetworkX-compatible API. Unlike NetworkX’s pure Python version, which is easy to use but limited in performance(undefaaq, ), rustworkx delivers up to 100× speedup and is used in production systems such as IBM’s Qiskit quantum computing framework (undefaar, ). This ensures that our comparisons reflect true algorithmic differences rather than implementation bottlenecks.

GSI

We also include GPU-friendly Subgraph Isomorphism (GSI) (undefae, ; undefaas, ) as a representative GPU-based baseline. GSI is a widely used GPU-oriented subgraph matching algorithm designed to improve parallel efficiency through GPU-centric execution strategies. In our evaluation, we report GSI results on benchmarks involving real-world network datasets with small pattern graphs, such as triangle enumeration, where the reference implementation is applicable. For experiments involving larger pattern graphs, GSI performance results were not included as the solution did not complete within reasonable execution time under our experimental settings or gave runtime errors due to out-of-memory.

Hardware Configurations

Our GPU-based experiments were conducted on the NVIDIA H200 GPU, part of the Hopper architecture family. This GPU is equipped with 132 streaming multiprocessors (SMs), each containing 128 scalar processors (SPs), totaling 16,896 SPs. It features 50MB of L2 cache and 144GB of HBM3e memory, and operates at a power envelope of 700W. The H200 uses the NVLink interface, which supports high-bandwidth interconnects suitable for multi-GPU communication. Although our current implementation runs on a single GPU, the underlying data-science abstraction of our solution is naturally extensible to multi-GPU settings for scaling to larger problems. For CPU-based benchmarking and the VF2 baseline, we used an AMD Ryzen Threadripper PRO 3995WX processor, built on the Zen 2 microarchitecture and running at 4.3 GHz. The CPU has 64 physical cores and supports 128 simultaneous threads, with 256MB of L3 cache and 1TB of DDR4-3200 system memory.

5.2. Benchmark Metrics on Runtime

The execution time of the $\Delta$-Motif algorithm comprises two phases: data preparation and computation. In the data preparation phase, the embeddings of required motif set, $Res(M)$, are computed and stored as dataframes for reuse. The computation phase then decomposes the pattern graph and executes dataframe join-and-filter operations to produce the final matches.

In many scenarios, the same data graph is queried repeatedly with different pattern graphs, such as in quantum circuit compilation (undefh, ) or in streaming subgraph isomorphism (undefaat, ), which arises in domains including social network analysis, chemistry, and biology. In such cases, the data preparation phase can be performed once, cached, and reused, allowing its cost to be excluded from subsequent queries and leaving only the pattern-searching phase. This reuse can deliver significant runtime savings and further speedups. To highlight this potential, we also report results with data preparation time omitted, in Section 6 marked as $\Delta$-Motif GPU∗.

We observed minimal runtime variance when running VF2 and $\Delta$-Motif multiple times on the same $(G_{d},G_{p})$ configuration. Therefore, given the large number of test cases and the long runtime, we report results from a single execution for each $(G_{d},G_{p})$ configuration.

6. Benchmarks and Results

We evaluate our GPU-accelerated, motif-based subgraph isomorphism approach using two complementary benchmark suites. The first measures the performance of $\Delta$-Motif on large data graphs with small pattern graphs, such as social network analysis workloads. The second evaluates performance on graph instances motivated by quantum circuit compilation, which feature structured data graphs and comparatively large pattern graphs.

6.1. Social Network Analysis Using Real World Networks

Triangle-counting, clustering coefficients, and $k$-truss analysis are all based on finding and enumerating triangles ($M_{3\text{-}O}$) in a graph and are extremely popular metrics in the fields of social network analysis, cyber-security and biological networks. Given its significance, our first benchmark evaluates $\Delta$-Motif using $M_{3\text{-}O}$ as the pattern graph on several datasets from the SparseSuite Matrix Collection (undefaau, ). Table 1 summarizes these tested networks. For instance, coAuthorsCiteseer and citationCiteseer are representative social networks with irregular topologies that follow a power-law distribution. We compare our $\Delta$-Motif algorithm on GPU against VF2 algorithm on CPU and GSI on GPU, and report both the wall-clock times and the speedups in Fig. 3. We also evaluated EGSM on these datasets, but it produced inconsistent results on loop-like pattern graphs, so we do not report its performance in the benchmarks.

For most of the tested networks, VF2 requires well over 200 seconds and can take up to 385 seconds in some cases. In contrast, GSI completes within 2–10 seconds, while $\Delta$-Motif on GPU consistently finishes in just 1–2 seconds. This substantial reduction in runtime demonstrates the ability of $\Delta$-Motif to efficiently handle real-world social network graphs of varying size and complexity. Overall, $\Delta$-Motif achieves speedups of $82\times$–$323\times$ on a single GPU compared to a single CPU core running VF2, whereas GSI achieves speedups of $28\times$–$145\times$.

Such improvements are particularly important for application domains such as social network analysis and cyber-security, where subgraph matching is often performed repeatedly at scale under strict time constraints. As a point of reference, achieving comparable performance using CPUs alone would require parallel execution across approximately 82–323 cores with near-perfect scalability, which is difficult to attain in practice given the limited number of cores within a single socket. By contrast, $\Delta$-Motif leverages a data-centric, massively parallel formulation that maps naturally to GPU hardware, making large-scale subgraph analysis both faster and more practical.

6.2. Subgraph Enumeration With Synthetic Subgraphs

In this section, we benchmark $\Delta$-Motif on several different topologies taken from the field of quantum computing. We use the heavy-hex lattice and the 2D square grid topologies, shown in Fig. 1(a) and (b). These geometries are common hardware constraints in state-of-the-art superconducting quantum processors. For each topology, we consider two sizes that reflect the projected number of qubits for near-future quantum devices: 1990 and 4485 vertices for the heavy-hex topology and 1600 and 3600 vertices for the square grid topology. Thus, our data graphs represent real-world graphs. For $\Delta$-Motif, we select motif sets tailored to each topology: {$M_{2}$, $M_{4}$} for heavy-hex and {$M_{2}$, $M_{4\text{-}O}$, $M_{6\text{-}O}$} for square grid.

For each data graph, we generate random connected subgraphs as pattern graphs of sizes ${20,40,60,80,100}$ vertices. For each pattern size, we sample 200 random seeds to capture structural variability. While the number of vertices is well defined, the number of edges varies slightly across seeds. For each case, we enumerate all isomorphic mappings using $\Delta$-Motif on GPU and the VF2 baseline on CPU. Speedups are reported as the ratio $T_{\text{VF2}}/T_{\Delta\text{-}Motif}$, with minimum, mean, and maximum values shown in Table 2.

Table 2 confirms a consistent performance advantage for $\Delta$-Motif GPU across all configurations, with mean speedups ranging from $3\times$ on small patterns (which typically under-utilize the GPU) and up to $53.43\times$ on the largest cases. For smaller patterns, $\Delta$-Motif under-utilizes the GPU, and fixed launch and data-movement overheads constitute a larger fraction of the total runtime. Larger data graphs generally yield higher speedups; for example, increasing the square grid size from 1600 to 3600 vertices raises the mean speedup for 100-node patterns from $15.20\times$ to $53.43\times$. Medium-to-large patterns (60 nodes and above) generally achieve the highest speedups, particularly for the 3600-node square grid and 4485-node heavy-hex, where the parallel join-and-filter phase is fully leveraged, reaching maximum observed speedups of $415.20\times$ and $594.92\times$, respectively. While variability is observed across seeds, the minimum speedup remains above the VF2 baseline in nearly all cases. The few low-minimum cases (e.g., heavy-hex with 20-node patterns) arise when the pattern size is sufficiently small that GPU launch overhead dominates the runtime.

We additionally compare $\Delta$-Motif against GSI where results are available. On smaller instances, such as the 1600-node square grid with 20-node patterns, the two methods show comparable average performance, measured by the mean speedup $T_{\text{GSI}}/T_{\Delta\text{-}Motif}$, with maximum speedups of up to $17\times$. As problem difficulty increases, the performance gap widens. For the 3600-node square grid with 20-node patterns, $\Delta$-Motif is on average $2\times$ faster than GSI, with maximum speedups reaching $63\times$. For larger patterns, GSI fails to complete within a reasonable time window, while $\Delta$-Motif continues to scale effectively.

Overall, the results show that $\Delta$-Motif consistently outperforms VF2 and increasingly outperforms GSI as problem size and complexity grow, with the largest benefits realized on large data graphs and medium-to-large pattern sizes that maximize GPU utilization. We also note that pattern graph decomposition accounts for less than 1% of the total runtime in all cases, with end-to-end execution completing in just a few seconds.

6.3. Performance Impact of Motif Selection

The experiments in Fig. 4 assess how different motif selection strategies influence runtime, speedup, and decomposition behavior on two data graphs. Each experiment uses 60-node random pattern graphs and compares VF2 with $\Delta$-Motif executed on CPU, on GPU, and on GPU with data preparation time excluded (marked as GPU∗).111We focus on 60-node patterns rather than 100-node ones, since CPU execution times for the latter were too long.. Bars show mean values over 50 random seeds, with error bars representing the minimum and maximum values. The three subplot columns present total runtime, speedups over VF2, and the average number of iterations for pattern decomposition using the chosen motif set.

Across both heavy-hex and square grid topologies, the GPU version of $\Delta$-Motif achieves the lowest execution times, often providing speedups of one to two orders of magnitude compared to VF2. Excluding the one-time data preparation step yields even greater gains, highlighting the benefit of caching in repeated-query scenarios. The CPU version also outperforms VF2 in most cases, although the margins are smaller.

The choice of motif has a strong impact on performance. The baseline motif $M_{2}$, discussed in Sec. 4.2 is functionally similar to a parallelized tree search, delivers only modest speedups because it produces as many decomposition iterations as the number of edges in the pattern graph. Using larger motifs can substantially reduce the iteration count, which in return lowers the volume of intermediate data processed during the join-and-filter stages. This reduction often translates directly into faster runtimes. However, this benefit depends on the topology of the data graph. In higher connectivity graphs such as the square grid, larger motifs tend to create much larger intermediate joins, which increase memory requirements and can offset iteration savings. In contrast, on lower-connectivity heavy-hex graphs, the same motifs are more effective, benefiting from iteration reduction without incurring excessive intermediate results. Lastly, in Fig. 4(c) and (f), the average number of $M_{2}$ iterations matches the average edge count of the pattern graphs and shows little variance, whereas decompositions with larger motifs exhibit much greater variability.

Importantly, simply increasing motif size does not guarantee better speedups. The most effective motifs also appear frequently as repetitive patterns in the data graph. For example, $M_{12\text{-}O}$ and $M_{18\text{-}O\text{-}6}$ for heavy-hex, and $M_{4\text{-}O}$ and $M_{6\text{-}2O}$ for square grids, outperform other motifs of similar size with less representative structure. These results indicate that motif selection should be topology-aware: low-connectivity graphs benefit from large, frequent motifs to reduce iterations, while high-connectivity graphs often require more moderate motifs to balance iteration count with manageable join complexity, allowing the GPU-accelerated join-and-filter pipeline to operate at peak efficiency.

6.4. Impact of Solution Size on Performance

Fig. 5 investigates how the number of outputted solutions, aka the number of enumerated isomorphic subgraphs, impacts the relative performance of $\Delta$-Motif compared to VF2. For this plot, we fixed the pattern graph size at 60 nodes but sampled 200 random seeds to generate distinct pattern subgraphs. These variations lead to different numbers of isomorphic matches, which directly impact the size of intermediate data processed during computation. For this experiment, we used motif sets {$M_{2}$, $M_{4\text{-}1}$} on the heavy-hex lattice and {$M_{2}$, $M_{4\text{-}O}$} on the square grid.

Across both heavy-hex and square grid data graphs, the GPU $\Delta$-Motif implementation consistently outperforms its CPU implementation and VF2. Speedups generally increase with the number of solutions, as larger solution sets generate more intermediate data and expose greater parallelism for the GPU to exploit. When the number of solutions is small, speedups are more modest since the parallel workload is limited and GPU launch overheads become more significant. Comparing GPU to GPU∗ reveals that data preparation can be costly in some cases. This gap is more evident in cases with smaller solution sets, where compute time is short and preparation overhead dominates. As the solution count grows, speedups for GPU∗ version can exceed two orders of magnitude, showing the efficiency of parallel join-and-filter operations on substantial datasets.

Square grid graphs, with their higher connectivity, present a more challenging search space than heavy-hex graphs. Higher connectivity increases branching and often inflates intermediate join sizes, especially for complex patterns. In such cases, when the number of solutions is small, the CPU can remain relatively efficient because intermediate data volumes are still moderate and GPU parallelism is underutilized. This is reflected in Fig. 5(a), where $\Delta$-Motif on CPU outperforms VF2 in about half of the heavy-hex cases and in most square-grid cases. Although some slowdowns occur, the overall trend shows that $\Delta$-Motif is also effective for CPU execution, particularly on the square-grid inputs. Overall, these results highlight that $\Delta$-Motif benefits most from GPU acceleration at scale, and that reusing precomputed data in repeated-query scenarios can significantly amplify these gains.

6.5. End-to-End Transpilation Benchmark

Recall that in Sec. 2.1, layout selection in quantum compilation can be understood as the process of enumerating all isomorphic subgraphs and then evaluating them with a cost function to identify the optimal choice. In quantum terminology, these stages are referred to as 1) layout generation, which employs a subgraph isomorphism subroutine (the central focus of this work), and 2) layout scoring, which applies a well-defined cost function to each candidate subgraph and then outputs the optimal one. Each layout’s score represents the estimated fidelity of executing the quantum algorithm on that particular mapping, taking into account the distinct physical characteristics of the qubits it spans, so that layouts leveraging higher-quality qubits naturally yield higher scores.

Note that layout scoring is also critical to end-to-end performance, as an inefficient implementation can significantly impact runtime. In $\Delta$-Motif, we chose to compute the scores at the level of motif embeddings $Res(M)$ rather than waiting for full solutions. The fidelity scores are stored as a new column in $Res(M)$ and updated incrementally after each subsequent join by multiplying the joined fidelity columns. By the end of the process, the total fidelity score for each subgraph is directly available. This scoring approach benefits from our tabular data structure, allowing fidelity evaluations to be embedded directly into the same relational operations used for candidate generation. As a result, our scoring extension adds trivial overhead and remains highly efficient, as shown in our later benchmarks.

In this benchmark, we integrated the $\Delta$-Motif algorithm into a complete quantum transpilation pipeline for layout selection. We compared our approach against Qiskit’s VF2PostLayout transpiler pass (undefaar, ), which relies on rustworkx’s VF2 implementation for layout generation, followed by a sequential Python-based scoring function for candidate scoring (undefh, ).222The scoring stage is sequential for undirected data graphs, which we use because they yield more isomorphisms. While some quantum hardware supports only directed two-qubit operations, reversing the direction in the postprocessing is trivial in practice, allowing us to consider a much larger space of feasible layouts using the undirected model. Note that although the design of scoring cost functions is an active research topic in quantum computing, it is not the focus of this work. Here, we adopt the same cost function as used in (undefh, ).

The data graph was derived from the qubit connectivity of IBM’s ibmq_fez, a state-of-the-art 156-qubit quantum processor (represented as a 156-node graph). We benchmark our pipeline on a diverse set of pattern graphs obtained from quantum circuits in the QASMBench benchmark suite (undefaav, ), covering sizes from 30 to 70 qubits and including a scaling set of Bernstein–Vazirani (BV) circuits.333Before layout selection, all input logical circuits are pre-transpiled with Qiskit (opt_level=1) to ensure that every two-qubit operation is mapped to physically connected qubits, making the resulting pattern graphs valid subgraphs of the device connectivity.

Results are presented in Fig. 6. Panel (a) reports the total wall-clock time for layout selection, broken down into layout generation and other components (primarily scoring). For VF2PostLayout, the sequential Python-based scoring often dominates the runtime, whereas $\Delta$-Motif maintains highly efficient scoring through its tabular design. To highlight our core algorithmic innovation, panel (b) only reports speedups for layout generation (i.e., subgraph isomorphism) relative to VF2. Across this varied workload, GPU implementations of $\Delta$-Motif consistently outperform VF2 by up to two orders of magnitude. For very small circuits or cases with small number of layouts, all methods complete layout generation quickly and GPU launch overheads dominate the runtime, so speedups are modest. However in these cases, the sequential layout scoring in VF2 becomes the main bottleneck. In contrast, when circuits yield many valid layouts on the 156-qubit device, the larger intermediate search spaces amplify GPU advantages. This trend is especially clear in the BV scaling experiments, where the 40-qubit BV circuit produces the most layouts and exposes greater parallelism.

These results illustrate a different but realistic challenge: when data graphs are only a few hundred nodes but pattern graphs approach half that size, the number of isomorphic subgraphs can also be enormous. Unlike the large-graph cases common in data science (e.g., Section 6.1), here the challenge stems from dense search spaces rather than graph scale. In this setting, VF2PostLayout suffers from sequential bottlenecks in both layout generation and scoring, resulting in high runtimes and unstable performance. By contrast, $\Delta$-Motif delivers strong and stable execution with total runtimes well under one second while avoiding the spikes and fluctuations seen in VF2. Notably, our tabular-based scoring, implemented with parallel relational join operations, adds minimal overhead and is almost negligible in the total runtime.

These results demonstrate that our data-centric approach delivers highly efficient end-to-end layout selection, maintaining strong performance across a wide range of circuit structures and sizes relevant to near-term quantum computers. Looking ahead, as quantum devices scale to hundreds or even thousands of qubits in the coming years, the scalability trends observed in the previous subsections provide strong evidence that the proposed method can continue to deliver substantial performance benefits in future large-scale systems.

7. Conclusion

In this paper, we introduce $\Delta$-Motif, a novel parallel algorithm for the enumeration of subgraph isomorphisms that transforms the traditional sequential and recursive search problem into a massively parallel data-processing task. Instead of relying on depth-first exploration, $\Delta$-Motif uses database primitives such as join, merge, and filtering operations to dynamically build candidate mappings while pruning invalid candidates on the fly, ensuring that only valid matches remain through completion.

The key innovation of $\Delta$-Motif lies in decomposing the pattern graph into smaller motifs, enabling broad and inherent parallelism by exploring all viable candidates simultaneously in a single hop. While this departs from traditional recursive tree-search and prune approaches, we show $\Delta$-Motif can be viewed as a parallel analogue of those methods, but without their inherent sequential bottlenecks.

We implement $\Delta$-Motif using open-source, commodity software that effectively exploits the parallelism of NVIDIA GPUs. Our design avoids hardware-specific kernels and instead leverages highly optimized RAPIDS libraries, enabling portability across accelerator platforms. This implementation consistently achieves order-of-magnitude performance improvements over VF2, with observed speedups of up to $595\times$ in favorable cases, and outperforms the GPU-based approach GSI in benchmarks where direct comparison is applicable. To the best of our knowledge, $\Delta$-Motif is the first GPU-based subgraph isomorphism approach implemented entirely using database-style relational primitives. Given the uniqueness of our solution, we believe this approach not only provides a powerful new tool for graph analysis but also opens new directions for research at the intersection of databases, graph algorithms, and high-performance computing.

Acknowledgements.

We thank Bradley Dice for valuable discussions and support. We are also grateful to our colleagues at Q-CTRL, NVIDIA, and Oxford Quantum Circuits, whose technical expertise, product engineering, and design efforts contributed significantly to the results presented in this paper.