Split-and-Match Algorithm

• Split-and-match algorithm is a decomposition paradigm that splits a global problem into manageable subproblems while preserving essential cross-boundary interactions.
• It finds applications in multiterminal compression, quadratic programming, query processing, graph algorithms, and minimal perfect hashing to improve efficiency and scalability.
• The framework leverages encoded boundary conditions and submodular properties to enable parallel, distributed processing and reduce computational complexity.

Searching arXiv for the cited work and closely related uses of split-and-match terminology. arxiv_search(query="split-and-match algorithm arXiv split join split decomposition matching", max_results=10) arxiv_search({"query":"split-and-match algorithm arXiv split join split decomposition matching","max_results":10}) “Split-and-match algorithm” denotes a family of decomposition procedures in which a global object is partitioned into smaller subproblems, local solutions are computed under explicit boundary conditions, and the resulting pieces are coordinated, concatenated, or unioned to recover a global solution. In the arXiv literature, the phrase does not identify a single canonical routine; rather, it appears across multiterminal lossless data compression, large-scale quadratic programming, cyclic join processing, graph algorithms based on split decomposition, and minimal perfect hashing (Ding et al., 2018, Vandelli et al., 21 Mar 2025, He et al., 29 Oct 2025, Ducoffe et al., 2018, Esposito et al., 2019). A common thread is that the split step is not merely a heuristic partition: the effective methods preserve cross-part interactions through submodular constraints, external fields, co-splits, compact partial-solution profiles, or stored split indices.

1. Scope and terminology

The literature uses “split” in several technically distinct senses. In Slepian–Wolf coding, the split is over subsets of terminals; in large-scale quadratic programs, over clusters of variables; in join processing, over heavy and light partitions of relations; in bounded split-width graph algorithms, over components of a split decomposition; and in minimal perfect hashing, over recursively partitioned key buckets. The “match” step is likewise domain-dependent: it can mean concatenation of rate vectors, aggregation of block solutions into a global assignment, union of subquery results, reconstruction of a global matching from component summaries, or composition of local bijections into a minimal perfect hash (Ding et al., 2018, Vandelli et al., 21 Mar 2025, He et al., 29 Oct 2025, Ducoffe et al., 2018, Esposito et al., 2019).

Setting	Split object	Combination step
Multiterminal compression	Terminal subset $C$ into $\hat{X}$ and $C \setminus \hat{X}$	Concatenate recursive rate allocations
Quadratic programming	Variable graph into disjoint clusters $\mathcal{G}_k$	Concatenate $X_k$, evaluate $H(X)$, optional sweep update
Query processing	Relations into heavy/light parts	Execute per-split plans and return $\bigcup_i Q(I_i)$
$b$-Matching on split-width graphs	Split decomposition components	Bottom-up profiles, then top-down reconstruction
Minimal perfect hashing	Buckets and recursive split tree nodes	Offset composition and leaf bijection

A common misconception is that “split-and-match” necessarily refers to literal graph matching. The published usage is broader. Literal matching is central in $b$-Matching and equimatchable split graphs, but in database systems and quadratic optimization the second phase is instead a reconciliation of partial solutions or query results (Ducoffe et al., 2018, Yıldız, 2019, Vandelli et al., 21 Mar 2025, He et al., 29 Oct 2025).

2. Shared algorithmic pattern

Despite the domain variation, the strongest formulations share three structural elements. First, they define a decomposition rule that is computationally meaningful rather than arbitrary. Examples include choosing the maximal minimizer of $f(X)-\lambda w(X)$ in the weighted egalitarian Slepian–Wolf problem, partitioning a variable interaction graph into clusters, splitting relations by degree thresholds, computing a canonical split decomposition, or recursively finding a hash-induced ordered partition of a key set (Ding et al., 2018, Vandelli et al., 21 Mar 2025, He et al., 29 Oct 2025, Ducoffe et al., 2018, Esposito et al., 2019).

Second, they carry boundary information across subproblems. In multiterminal compression, submodular structure and recursive updates of the residual function preserve feasibility. In quadratic programming, the local external field

$\hat{X}$0

encodes cross-cluster influence, and

$\hat{X}$1

corrects double counting (Vandelli et al., 21 Mar 2025). In SplitJoin, co-splits and per-split join orders propagate degree information across joins (He et al., 29 Oct 2025). In $\hat{X}$2-Matching, the entire range of feasible interactions across a split is summarized by a compact piecewise-linear profile $\hat{X}$3 and a constant-size module gadget (Ducoffe et al., 2018). In RecSplit, only split and bijection indices must be stored because the recursive tree shape is implicit in the chosen strategy (Esposito et al., 2019).

Third, they exploit independence once boundary conditions are fixed. This is the source of parallelism. In the compression SPLIT algorithm, the two recursive branches after a split are independent given the intermediate rate assignment (Ding et al., 2018). In the quadratic-program SPLIT framework, all subproblems $\hat{X}$4 are independent within an iteration once $\hat{X}$5 is fixed (Vandelli et al., 21 Mar 2025). In SplitJoin, each split subinstance can be optimized separately and the final answer is the union of subinstance results (He et al., 29 Oct 2025). In RecSplit, buckets are independent after the initial partitioning (Esposito et al., 2019).

3. Weighted egalitarian coding in the Slepian–Wolf region

A precise and fully specified split procedure appears in “Fairness in Multiterminal Data Compression: A Splitting Method for The Egalitarian Solution” (Ding et al., 2018). The setting is the multiterminal lossless data compression problem. For a set of sources $\hat{X}$6, with each source $\hat{X}$7 observing a discrete random variable $\hat{X}$8, the Slepian–Wolf rate region $\hat{X}$9 is given by

$C \setminus \hat{X}$0

and

$C \setminus \hat{X}$1

Because the entropy function $C \setminus \hat{X}$2 is submodular, the region is a base polyhedron, and this submodularity is the key property exploited by the algorithm.

The fairness criterion is the weighted egalitarian solution

$C \setminus \hat{X}$3

where $C \setminus \hat{X}$4 may reflect energy reserve or channel quality. The algorithm processes a subset $C \setminus \hat{X}$5 with submodular function $C \setminus \hat{X}$6 and weights $C \setminus \hat{X}$7. It sets

$C \setminus \hat{X}$8

finds the maximal minimizer

$C \setminus \hat{X}$9

and either terminates with proportional allocation $\mathcal{G}_k$0 if $\mathcal{G}_k$1, or recursively splits into $\mathcal{G}_k$2 and $\mathcal{G}_k$3. For the residual branch it defines

$\mathcal{G}_k$4

and concatenates the two recursive solutions.

The computational core is submodular function minimization. Each call is strongly polynomial in $\mathcal{G}_k$5, the recursion depth is at most $\mathcal{G}_k$6, and the overall complexity is

$\mathcal{G}_k$7

The paper contrasts this with the combinatorial Shapley-value computation over the Slepian–Wolf region, which requires summing over all $\mathcal{G}_k$8 subsets. The same paper states that the SPLIT algorithm is strongly polynomial, adaptively updates source coding rates to the optimal solution, enables parallel and distributed computation, and yields an egalitarian solution that is superior to the Shapley value in distributed networks such as wireless sensor networks because it best balances energy consumption and is far less computationally complex to obtain (Ding et al., 2018).

The experimental claims are specific. For random sources with $\mathcal{G}_k$9 up to $X_k$0, the metric compares the sum of SFM problem sizes per recursion in centralized execution against the maximum recursion SFM size at each level in parallel execution, and the reported outcome is a substantial reduction in completion time as $X_k$1 increases. In a three-user example, the maximum per-node rate is reduced by $X_k$2 compared to the Shapley value, with network lifetime improved by a factor of $X_k$3 (Ding et al., 2018).

4. Cross-interaction-aware splitting in quadratic programming and query processing

A second major instantiation is “Parallel splitting method for large-scale quadratic programs” (Vandelli et al., 21 Mar 2025). The target problem is a quadratic program

$X_k$4

The variables are partitioned into $X_k$5 disjoint clusters $X_k$6. For cluster $X_k$7, the subproblem objective is

$X_k$8

where the local external field $X_k$9 captures the current influence of variables outside the cluster. The framework is iterative: compute all $H(X)$0, solve all subproblems in parallel, concatenate the updated $H(X)$1, evaluate the global cost, stop if converged, or apply an optional greedy sweep update. The paper explicitly distinguishes this from simpler split-and-match heuristics by emphasizing iterative updates of $H(X)$2, correction terms $H(X)$3, and greedy sweep refinement.

The performance claims are correspondingly concrete. For binary variables and $H(X)$4 processing units, the stated complexity is $H(X)$5. The framework is solver-agnostic and can use branch-and-bound, CPLEX, or quantum subproblem solvers. Experiments on MaxCut and Antenna Placement instances with up to $H(X)$6 decision variables report orders-of-magnitude wall-clock reductions relative to sequential CPLEX exact solve, and near-optimal solutions with typical approximation ratio $H(X)$7 (Vandelli et al., 21 Mar 2025).

A database-oriented realization appears in “One Join Order Does Not Fit All: Reducing Intermediate Results with Per-Split Query Plans” (He et al., 29 Oct 2025). SplitJoin introduces split as a first-class query operator. For a relation $H(X)$8 and attribute $H(X)$9, values are heavy if they occur more than a threshold $\bigcup_i Q(I_i)$0, and $\bigcup_i Q(I_i)$1 is partitioned into $\bigcup_i Q(I_i)$2 and $\bigcup_i Q(I_i)$3. The split phase recursively partitions the instance according to a split set $\bigcup_i Q(I_i)$4; the join phase optimizes each resulting subinstance separately and returns

$\bigcup_i Q(I_i)$5

The framework formalizes a “light joins first” principle, uses co-splits when multiple relations join on the same key, and adapts split-and-match ideas from theory to a practical front-end for DuckDB and Umbra.

The theoretical guarantee is phrased via the AGM bound. For binary joins on relations up to $\bigcup_i Q(I_i)$6 rows, SplitJoin can guarantee all intermediates are at most $\bigcup_i Q(I_i)$7, where $\bigcup_i Q(I_i)$8 is the fractional edge cover number. The empirical results are unusually explicit: on DuckDB, SplitJoin completes $\bigcup_i Q(I_i)$9 social network queries versus $b$0 natively, with $b$1 faster runtime and $b$2 smaller intermediates on average, and up to $b$3 and $b$4, respectively; on Umbra, it completes $b$5 queries versus $b$6, with $b$7 speedups and $b$8 smaller intermediates on average, up to $b$9 and $b$0 (He et al., 29 Oct 2025).

These two systems illustrate a recurring point: splitting is not synonymous with discarding global structure. In both papers, the boundary terms are explicit—external fields in quadratic programming, and skew-aware degree partitions plus per-split join optimization in query processing.

5. Split decomposition, literal matching, and recognition on split graphs

In graph algorithms, the term meets its most literal interpretation. “A quasi linear-time $b$1-Matching algorithm on distance-hereditary graphs and bounded split-width graphs” (Ducoffe et al., 2018) begins from split decomposition. A split in a graph $b$2 is a partition $b$3 with $b$4 such that the edges between $b$5 and $b$6 form a complete bipartite graph between subsets $b$7 and $b$8. The objective of unit-cost $b$9-Matching is to choose nonnegative integer edge weights maximizing $f(X)-\lambda w(X)$0 subject to $f(X)-\lambda w(X)$1 for every vertex $f(X)-\lambda w(X)$2.

The central obstacle is non-locality: an augmenting path may cross the subgraphs of a split decomposition arbitrarily, so ordinary decomposition-based dynamic programming does not apply. The paper overcomes this by encoding all possible partial solutions for a side of a split through a piecewise-linear profile. For a marker vertex $f(X)-\lambda w(X)$3, if $f(X)-\lambda w(X)$4 denotes the maximum size of a $f(X)-\lambda w(X)$5-matching when $f(X)-\lambda w(X)$6, then there exist integers $f(X)-\lambda w(X)$7 such that

$f(X)-\lambda w(X)$8

This profile is represented by replacing a marker vertex with a constant-size module $f(X)-\lambda w(X)$9, where $\hat{X}$00 has capacity $\hat{X}$01, $\hat{X}$02 and $\hat{X}$03 have capacity $\hat{X}$04, and $\hat{X}$05 is an edge. A bottom-up dynamic program computes these summaries, and a top-down pass reconstructs the explicit global solution.

The resulting algorithm reduces $\hat{X}$06-Matching on $\hat{X}$07 to $\hat{X}$08-Matching on a collection of smaller graphs produced from the split components by constant-size substitutions. If every component in the split decomposition has order at most $\hat{X}$09, the time bound is

$\hat{X}$10

and this answers the open question of Coudert et al. on quasi linear-time maximum matching for bounded split-width graphs (Ducoffe et al., 2018).

A structurally different but related line appears in “Linear Time Recognition of Equimatchable Split Graphs” (Yıldız, 2019). Here a split graph is one whose vertex set can be partitioned into a clique $\hat{X}$11 and an independent set $\hat{X}$12. The paper gives a linear-time recognition algorithm, EquiSplit, for deciding whether all maximal matchings have the same cardinality. Its characterization is degree-sequence based, with five exhaustive cases including complete graphs, stars, and several two-special-vertex configurations. The algorithm computes a non-decreasing degree ordering and counters $\hat{X}$13, $\hat{X}$14, and $\hat{X}$15, then checks the cases in $\hat{X}$16 time. Although the paper does not define a generic split-and-match framework, its structural analysis explicitly uses split-graph partitions and matching constraints, and the supplied summary describes the reasoning as “split-and-match” in the sense of stepwise interaction between $\hat{X}$17 and $\hat{X}$18 (Yıldız, 2019).

6. Recursive splitting in minimal perfect hashing

“RecSplit: Minimal Perfect Hashing via Recursive Splitting” (Esposito et al., 2019) transposes the paradigm into succinct data structures. A minimal perfect hash function bijectively maps a static key set $\hat{X}$19 to $\hat{X}$20. RecSplit first partitions keys into buckets of average size $\hat{X}$21 using a random hash function $\hat{X}$22, then recursively splits each bucket until the subset size is at most a leaf threshold $\hat{X}$23. Leaves are solved by brute-force search for the first bijective hash function.

For a subset $\hat{X}$24 of size $\hat{X}$25 split into $\hat{X}$26 ordered parts of sizes $\hat{X}$27, the success probability of a trial is

$\hat{X}$28

At the leaves, the expected number of trials to find a bijection is $\hat{X}$29. Every internal split and every leaf bijection stores only the index $\hat{X}$30 of the first successful hash in a family $\hat{X}$31, and these indices are compressed with Golomb–Rice codes; Elias–Fano structures store bucket offsets and prefix sums.

The paper explicitly positions RecSplit relative to earlier split-and-match methods attributed to Sprugnoli and Jaeschke. The reported distinction is that RecSplit uses systematic recursion rather than a fixed one-level split, analyzes the process probabilistically, and achieves a much more compact representation. The empirical claims are specific: expected linear construction time, expected constant lookup time, and practical space as low as $\hat{X}$32 bits per key, which is within $\hat{X}$33 of the lower bound $\hat{X}$34 bits per key. The construction can be easily parallelized or mapped on distributed computational units, including MapReduce, and structures larger than the available RAM can be directly built in mass storage (Esposito et al., 2019).

This suggests that, in data-structural settings, “match” corresponds less to reconciling multiple partial answers than to preserving a consistent global numbering. The recursive split tree determines the path of a key, while offsets accumulated along that path ensure that the final index is both unique and minimal.

7. Complexity regimes, parallelism, and limits of the paradigm

Across these papers, the chief computational benefit of split-and-match methods is that wall-clock time can depend on the largest active subproblem rather than the full original instance, provided the decomposition preserves sufficient information. The compression SPLIT algorithm is strongly polynomial and parallelizable across recursive branches (Ding et al., 2018). The quadratic-program SPLIT framework achieves parallelism because subproblems are independent within an iteration once the external fields are fixed, and the paper states that if the number of processors scales with $\hat{X}$35, wall-clock time depends only on the largest subproblem (Vandelli et al., 21 Mar 2025). SplitJoin reduces intermediate results by selecting split thresholds and per-split join orders, and its improvements are largest on cyclic queries over skewed data (He et al., 29 Oct 2025). RecSplit isolates buckets completely after the initial hashing stage, enabling distributed construction (Esposito et al., 2019).

The main limitation is that splitting alone is insufficient when cross-part interactions are strong or when the summary of those interactions is not compact. This point is made in different forms throughout the literature. In bounded split-width $\hat{X}$36-Matching, the obstacle is augmenting paths crossing components arbitrarily; the remedy is the piecewise-linear profile and module gadget (Ducoffe et al., 2018). In quadratic programming, ignoring cross-cluster couplings would bias the objective; the remedy is iterative field updates and the double-counting correction (Vandelli et al., 21 Mar 2025). In query processing, naïve splitting can create unnecessary overhead; SplitJoin therefore skips splits when the heavy set is too small or not skewed (He et al., 29 Oct 2025). In RecSplit, the recursion remains practical only because leaves are small enough for brute-force search and because the split indices have favorable coding distributions (Esposito et al., 2019).

A further misconception is that all split-based methods target identical optimality notions. The record is more heterogeneous. The multiterminal coding algorithm is exact for a convex fairness objective over a submodular base polyhedron (Ding et al., 2018). The bounded split-width $\hat{X}$37-Matching algorithm is exact and quasi linear-time under a structural parameter (Ducoffe et al., 2018). SplitJoin combines worst-case guarantees on intermediate sizes with optimizer heuristics for threshold selection and split scheduling (He et al., 29 Oct 2025). The quadratic-program SPLIT framework is a decomposition heuristic aimed at high-quality solutions under strict time or hardware limits (Vandelli et al., 21 Mar 2025). RecSplit is exact as a minimal perfect hash construction, but its efficiency claims are probabilistic and expectation-based (Esposito et al., 2019).

Taken together, these works indicate that “split-and-match” is best understood as a reusable algorithmic schema: decompose, encode interface structure, solve smaller pieces, and merge without losing the global invariants that matter for the objective. The invariant may be feasibility in a Slepian–Wolf base polyhedron, consistency of quadratic cross-terms, worst-case control of join intermediates, the profile of feasible boundary matchings, or the bijectivity of a hash family. The diversity of these invariants explains why the phrase names a paradigm rather than a single universally standardized algorithm.