Sparsity-Aware Split Finding

• The paper introduces sparsity-aware split finding in MILP branching by defining finite k-sparse split families and analyzing covering numbers to enhance efficient branch-and-bound performance.
• The paper applies sparsity constraints in group testing and compressed sensing, using recursive partitioning and dictionary splitting to lower test numbers and boost recovery thresholds.
• The paper presents algorithmic strategies including greedy covering and resource-aware neural splits, balancing computational cost and accuracy under sparsity constraints.

Sparsity-aware split finding refers to algorithmic and theoretical frameworks for designing, analyzing, and selecting splits with explicit structural sparsity constraints—typically in branching, partitioning, or compressed sensing contexts. The goal is to exploit or enforce sparsity, either to enable tractable search or to improve computational, memory, or statistical efficiency. Prominent uses include sparse split disjunctions in integer programming, sparsity-constrained test matrix design in group testing, and dictionary splitting to enhance sparse recovery guarantees.

1. Sparse Split Disjunctions in Binary MILP Branching

Let $n$ be the number of binary variables. A split disjunction is defined by integral data $(\pi,\pi_0) \in \mathbb{Z}^n \times \mathbb{Z}$ and partitions $\{0,1\}^n$ via

$$D(\pi, \pi_0) = \{x \in \mathbb{R}^n: \pi^Tx \leq \pi_0\} \cup \{x \in \mathbb{R}^n: \pi^Tx \geq \pi_0+1\}.$$

The open "split set" is $$S(\pi, \pi_0) = \{x \in \mathbb{R}^n: \pi_0 < \pi^Tx < \pi_0+1\}$$. Sparsity is imposed by constraining $\|\pi\|_0 \leq k$ for a prescribed $k$, yielding $k$-sparse splits. Sparsity-aware split finding in this context is the selection, enumeration, and combination of such $k$-sparse split sets for use in branch-and-bound algorithms for binary MILPs (Dey et al., 2024).

To organize the collection of such splits, a finite family $\mathcal{F}$ of $k$-sparse split sets is considered. Key to algorithmic efficiency is the concepts of dominance (one split set dominating another on $[0,1]^n$) and the covering number $\mathrm{Cover}(\mathcal{F})$:

• For any $k$-sparse split $S$, $\mathcal{F}(S)$ is the minimal number of elements of $\mathcal{F}$ whose union covers $S\cap[0,1]^n$.
• $$\mathrm{Cover}(\mathcal{F}) = \max_{k\text{-sparse }S}\mathcal{F}(S)$$ quantifies worst-case overhead in simulating arbitrary $k$-sparse splits using $\mathcal{F}$.

Fundamental results include:

• For $k=2$, the explicit, finite family $$\mathcal{F}_2 = \{S(\pi, \eta): \pi \in \{-1,0,1\}^n, \|\pi\|_0 \leq 2, \eta \in \{-2,\ldots,2\}\}$$ dominates all $2$-sparse splits.
• For $k \geq 3$, no finite family dominates all $k$-sparse splits: given any finite $\mathcal{F}$, there exist $k$-sparse splits that require simulating with unions.
• For $k \geq 4$, any finite $\mathcal{F}$ must have $$\mathrm{Cover}(\mathcal{F}) \geq \lfloor k/2 \rfloor$$.
• For canonical $\mathcal{F}_k$ with $\pi \in \{-1,0,1\}^n$ and $\|\pi\|_0 \leq k$, $\mathrm{Cover}(\mathcal{F}_k) \leq k-1$ for $k \leq 4$ (Dey et al., 2024).

The practical implication is that for $k \leq 4$, all necessary $k$-sparse splits can be precomputed, scored, and selected efficiently; for $k \geq 5$, any pre-specified finite list is insufficient, and coverage-based heuristics or online split generation is needed. The following table summarizes critical properties:

$k$	Finite Dominating List Exists?	$\mathrm{Cover}(\mathcal{F}_k)$ (upper bound)
2	Yes	1
3	No	2
4	No	3
$\geq 5$	No	$\geq \lfloor k/2\rfloor$

2. Sparsity-Constrained Group Testing via Fast Splitting

In nonadaptive group testing, sparsity-aware splitting designs test matrices under restrictions such as: (i) $\gamma$-divisible items (each item in at most $\gamma$ tests), or (ii) $\rho$-sized tests (each test pools at most $\rho$ items). The "splitting" terminology here refers to recursive partitioning of the item set, leveraging the assumed sparsity $k \ll n$ (number of defectives much less than number of items) to minimize the number of tests $T$, decoding time, and, critically, to conform to sparsity constraints (Price et al., 2021).

The settings and core results include:

• $\gamma$-divisible: O($\gamma k (n/k)^{1/\gamma}$) tests and time, with vanishing error probability for suitable split-tree-based algorithms.
• $\rho$-sized: O($n/\rho$) tests and decoding in O($n/\rho$) time, using constant-depth trees with restricted group sizes, for suitable parameter ranges.
• Under noise (test outcomes flipped with probability $p$), binary-splitting algorithms with repetition and path-based robustification achieve $T=O(k\log n)$ and $P_e \to 0$ for $n\to\infty$.

Hashing-based test assignment enables low-storage, on-the-fly assignment of items to tests to further reduce the memory footprint.

3. Dictionary Splitting for Improved Sparsity Thresholds

In compressed sensing, the recovery threshold for basis pursuit or $\ell_0$ minimization depends on the dictionary $D$'s coherence $\mu(D)$. The classical worst-case bound is

$\|x\|_0 < \frac{1 + 1/\mu(D)}{2}$

for unique recovery.

Sparsity-aware split finding here refers to partitioning the dictionary $D = [D_1 \; D_2]$ and using sub-block and cross-block coherence $(a, b, d)$ to derive a strictly better threshold for all splits:

$\|x\|_0 < T_{\mathrm{split}}(d, a, b)$

where $T_{\mathrm{split}}$ is explicit and always matches or exceeds the classic bound, with strict improvement whenever $a, b < d$ (0908.1676).

The optimal split is generally found by approximate combinatorial search (greedy swaps, spectral clustering), as exhaustive enumeration is infeasible for large $n$. This approach provides improved recovery guarantees particularly for structured dictionaries where coherence is inhomogeneous.

4. Algorithmic Strategies for Sparsity-Aware Split Finding

The construction of finite families of $k$-sparse split sets follows explicit enumeration for small $k$. The key pseudocode components are as follows (Dey et al., 2024):

def Build_Sparse_List(n, k): F = [] for support in all_subsets_of_size_up_to_k(range(n)): for signs in all_±1_assignments(support): for η in range(-k, k+1): F.append((π, η)) return F

When a split $S$ is outside the precomputed $F$, greedy set cover approximation can be used to represent $S$ as a union of a small number of splits from $F$:

def GreedyCover(S, F): U = S ∩ [0,1]^n F_prime = [] while U not empty: D = select_maximum_overlap(U, F) F_prime.append(D) U = U \ (D ∩ U) return F_prime

In group testing, test assignment is performed recursively on a hierarchy of subgroups, conforming to the prescribed sparsity constraints, with robust test assignment under noise managed via multiple repetitions and majority/path-vote labeling (Price et al., 2021).

5. Practical Implications and Trade-offs

In the binary MILP context, the coverage properties of $\mathcal{F}_k$ directly bound worst-case branch-and-bound tree size. For $k \leq 4$, precomputing and scoring all splits in $\mathcal{F}_k$ leads to efficient, fully-coverage branching with modest memory costs; for $k \geq 5$, any static squad of splits is provably insufficient, imposing a lower bound on tree depth and necessitating adaptive splitting or online generation. The exponential growth of $|\mathcal{F}_k|$ in $k$ and $n$ further compels practitioners to keep $k$ low in fixed-list regimes.

For group testing, sparsity-aware split finding enables near-optimal trade-off between tests, decoding complexity, and compliance with physical division constraints or test capacity (Price et al., 2021). Likewise, in compressed sensing, dictionary splitting improves recovery thresholds without altering problem dimension, provided an effective split can be found (0908.1676).

6. Connections to Sparsity-Aware Split Selection in Neural and Embedded Systems

Predefined sparsity applied to split computing and early exit in neural networks deploys a fixed sparsity mask before training. This reduces per-layer computation and memory linearly in density. The split-finding process searches for the layer (“split point”) that minimizes expected total cost, incorporating both compute on the edge (head) and server (tail), with all costs scaled by layer density. Practically, this yields up to $4\times$ reduction in storage and FLOPs, but selection of layer split and exit threshold must be coparameterized with sparsity to preserve accuracy and satisfy hardware constraints (Capogrosso et al., 2024).

7. Summary Table: Key Domains for Sparsity-Aware Split Finding

Domain	Split Type	Sparsity Constraint	Core Performance Metric
Binary MILP Branching	$k$-sparse split	$\|\pi\|_0 \leq k$	Covering number, tree size
Group Testing	Pool/test splitting	$\gamma$-divisible, $\rho$-sized	Number of tests, decoding time
Compressed Sensing	Dictionary split	Partition to sub-blocks (size $n_1$, $n_2$)	Recovery threshold improvement
Neural SC+EE	Layer split	Predefined per-layer density $\eta_i$	Expected cost/latency, accuracy

The sparsity-aware split finding paradigm unifies approaches across integer programming, compressed sensing, group testing, and resource-constrained computation, emphasizing explicit structural constraints and principled selection or design of splits to optimize both computational and statistical outcomes (Dey et al., 2024, Price et al., 2021, 0908.1676, Capogrosso et al., 2024).