Neural network verifiers prove that a network behaves safely on every input in a region. The leading tools use branch-and-bound: they cheaply over-estimate the worst case, and when that estimate is too loose they split the problem into smaller pieces and try again. The rule for where to split largely decides whether a proof finishes in seconds or times out, and today those rules are hand-designed for each domain. Separately, researchers who build automated "idea transfer" systems, which hand an AI agent a mechanism from another field and ask it to adapt that mechanism to a new problem, have reported an awkward result. Picking the source mechanism deliberately works no better than picking it at random, and the field cannot tell whether that finding is real, because its evaluations rest on small sets of LLM-judged text proposals.
We propose to join these two problems. The splitting rule in branch-and-bound is an unusually clean place to import ideas from other fields, because any rule that partitions the region leaves the proof sound; a bad rule only makes the verifier slower. That gives cross-domain transfer an objective scoreboard (problems solved under a fixed time limit) with no risk of producing false proofs. We will use it to ask two questions. First, can branching rules adapted from neighboring search disciplines, such as integer programming, SAT solving, and control reachability, beat the branching in the strongest current verifier? Second, does choosing the source discipline deliberately beat choosing it at random once quality is measured by solved instances rather than by an LLM judge?
Core Claim
The module boundary that branch-and-bound already enforces is what makes cross-domain transfer testable here. A Unified View of Piecewise Linear Neural Network Verification and Branch and Bound for Piecewise Linear Neural Network Verification showed that complete verifiers separate into two parts. A bounding engine must be mathematically sound. A branching rule only chooses which unstable activation to fix on or off, or which input coordinate to bisect. If imported ideas are confined to the branching rule, behind an interface that returns only a split decision, the soundness guarantee carries over unchanged. The heavy penalty for incorrect proofs in VNN-COMP 2024, −150 points against +10 for a correct proof, never comes into play.
We make two claims. The first is the substantive verification result: rules adapted from other search disciplines, chosen by deliberate analogy, will solve more instances than the default branching of α,β-CROWN within the same time limit. The effect should be largest on benchmarks where current rules are known to be brittle, namely deep residual networks and non-ReLU graphs. The second is the measurement result. We will either reproduce or overturn, on an objective metric, the finding of Read, Grep, and Synthesize that targeted cross-domain seeds tie random ones, with a 47% win rate. Either outcome on the second question is informative.
Research Program
The first component is a seed library of mechanisms from adjacent search fields. PaperGym's 1,167 seeds come from seven ML application domains, so they say almost nothing about search, and we cannot reuse them as the primary source. We will build a parallel library of problem–mechanism records from fields that solve the same abstract problem of choosing which variable to split in a tree search over a relaxation:
- integer programming, with pseudo-cost and reliability ideas;
- SAT and constraint solving, with conflict-driven activity scores and restarts;
- interval global optimization, with largest-width and smear-based splitting;
- set-based reachability for control systems, with generator-importance splitting.
We will use the tool-augmented extraction that PaperGym found raises specificity from 4.22 to 4.76 out of 5. Each record will be grouped by source field and tagged with its "fit rationale": the structural property of the target problem it relies on, such as monotone bound improvement or repeated similar subproblems. PaperGym's own ML-domain seeds will serve as a far-domain control pool.
The second component is the interface contract. An imported rule is a function that sees the current subdomain and returns a split decision. The subdomain information it can read includes:
- per-neuron pre-activation bounds and relaxation slopes;
- the history of bound improvements produced by earlier splits;
- the depth in the search tree;
- for input splitting, per-coordinate gradients of the bound.
The engine performs the split itself. This rules out unsoundness by construction. The contract also lets us detect "citation abandonment", PaperGym's term for an agent that names a borrowed concept without using its mathematics, mechanically rather than by reading the agent's text. We delete the operation that characterizes the seed, such as the pseudo-cost update or the activity-decay step. If the solve rate does not change, the transfer was nominal.
The third component is the transfer protocol. An agent receives a target benchmark family, one seed under one of several retrieval conditions, and a fixed budget of tuning runs on a development split. It writes a rule and tunes it, and the rule is then frozen and evaluated on held-out instances. The comparison conditions are:
- no retrieval;
- same-field retrieval, which supplies only verification papers such as the latent-space refinement of Out of the Shadows and the computational-graph branching of Shi et al.;
- targeted cross-field retrieval, matched on the fit rationale;
- random cross-field retrieval;
- far-domain PaperGym seeds.
To show the gain is not tied to one code base, we will run rules in two engines: α,β-CROWN, and the modular Julia toolbox ModelVerification.jl, whose multiple-dispatch design already separates branching from bounding. As a secondary target, we will apply the same protocol to the assumption-refinement step of the compositional verifier CoVeNN. There, a subnetwork's proven output range becomes the assumed input for the next subnetwork, and the ranges are currently guessed by sampling and loosened or tightened by hand-written rules. That step also cannot break soundness, because every assumption is still checked by the underlying verifier.
Baselines
The naive reference point is the splitting rule that needs no intelligence: bisect the widest input coordinate, or split the unstable neuron with the largest bound gap. Every verifier ships some version of this, and it shows how much of any gain comes from merely having a reasonable rule.
The strongest competitor is the default branching of α,β-CROWN. It won both tracks of VNN-COMP 2024, and that competition's top tools have converged on its GPU branch-and-bound design. The only reported figure for it in our material is an average time of 8.37 s on ACAS Xu property φ1, given in the ModelVerification.jl paper, which reports 3.34 s for its own engine on the same property. We will rerun α,β-CROWN ourselves on identical hardware and time limits rather than rely on those figures.
For the classic verifier BaBSB from Branch and Bound for Piecewise Linear Neural Network Verification, the reported figure is a 98.40% success rate on ACAS Xu within one hour, against 79.26% for Reluplex in two hours. ACAS Xu is therefore close to saturated, and the room to improve lies in solve time on ACAS Xu and in solved counts on harder benchmarks. On deep residual networks the reference is CoVeNN, which verified 95 of 140 CIFAR-10 ResNet problems, against 14 for NeuralSAT run alone.
Fairness requires that the baselines receive the same tuning the agent does. Each baseline's existing hyperparameters, such as branching-score weights, batch sizes, and restart settings, will be tuned by random search on the same development split, with the same number of verifier runs as the agent's budget. All methods share the same bounding engine, GPU, and per-instance time limit.
The key ablations isolate two things:
- The value of the imported mechanism. The seed-deleted rule from the abandonment test is the first ablation. A same-budget agent rule written with no seed separates the mechanism from generic agent tuning.
- The value of choosing the source field. Random-seed retrieval separates targeted selection from mere exposure to diverse mechanisms.
An imported rule counts as beating the field if it meets all three conditions:
- It solves more held-out instances than tuned α,β-CROWN default branching under the same limit.
- The improvement is statistically significant under a paired comparison across instances.
- It holds on at least two benchmark families that the rule was not developed on.
Why not just…?
Why not just tune the existing branching rule's hyperparameters harder? This is the most serious threat, and the design treats it as a full baseline, not a straw man. If equal-budget random search over α,β-CROWN's own parameters matches the agent-produced rules, the conclusion is that the bottleneck is tuning rather than ideas. That would itself be a useful negative result for the transfer literature. The held-out-family test is where we expect a difference: structurally new rules, such as activity scores that learn from earlier splits, should generalize across architectures better than re-weighted versions of the existing score. That is a hypothesis, not a known fact.
Why not just prompt a frontier model to "improve the branching rule" without retrieved seeds? This is the no-retrieval condition. PaperGym reports that cross-domain retrieval beats no retrieval 60% of the time and same-domain retrieval 67% of the time on judged proposals. Whether those margins survive an objective solve-rate metric is exactly what we test, so the experiment settles the question rather than assuming the answer.
Why not just use random seeds, since PaperGym found targeting doesn't help? We take that finding seriously and run random retrieval as a first-class condition. Our reason for doubting it carries over is specific. In PaperGym the "fit" between seed and problem was judged loosely across text domains. Here, the fit rationale is a checkable structural property of the target search problem. If targeted retrieval still only ties random retrieval, we will report that the paradox holds even with an objective metric and a structural notion of fit.
Why not just let the agent modify the bounding engine too, where larger gains might lie? Bounding code that is subtly wrong produces false proofs, and an agent that names a mechanism without implementing its mathematics would turn directly into unsoundness. Confining transfer to branching and to CoVeNN's assumption-refinement step costs some potential gain, and in return no result we report can be an incorrect proof. As a further check, we will compare every verdict against a reference verifier and, where available, against the checkable certificates of Abstraction-Based Proof Production.
Proposed Experiments
The development and held-out benchmark families are:
- ACAS Xu, where we measure solve time.
- Robust MNIST, PCAMNIST, and TwinStream from Branch and Bound for Piecewise Linear Neural Network Verification. These cover a range of perturbation sizes, network depths and widths, and correlated layers. We found no reported result on Lacuna for current verifiers on them.
- The CIFAR-10 ResNet suite from CoVeNN, where we count solved problems out of 140 and measure memory.
- The VNN-COMP 2024 suite, including safeNLP, Collins RUL, and ml4acopf. On ml4acopf, the trigonometric layers exercise the computational-graph branching of Shi et al..
Rules are developed on one family and frozen. They are then scored on the others by solved count, PAR-2 time (the average runtime with timeouts counted at twice the limit), and search-tree size.
Three checks decide the outcome:
- Whether imported rules beat tuned α,β-CROWN on held-out families with the bounding engine held fixed. This answers the verification question.
- Whether targeted retrieval beats random retrieval on solved-instance win rate across at least 60 benchmark-family-by-seed trials, twice PaperGym's 30 queries. A two-sided sign test gives a direct objective counterpart to PaperGym's 47% figure.
- Whether deleting the seed's mechanism removes the gain. If it removes the gain for targeted seeds but not for random ones, borrowed mathematics drives the improvement, not the agent's general tuning skill. That would locate the "why" that PaperGym found missing.
If the first check fails, the work still yields an objective, soundness-safe benchmark for cross-domain transfer, something the ideation literature currently lacks.
References
- A Unified View of Piecewise Linear Neural Network Verification
- Branch and Bound for Piecewise Linear Neural Network Verification
- The Fifth International Verification of Neural Networks Competition (VNN-COMP 2024): Summary and Results
- Read, Grep, and Synthesize: Diagnosing Cross-Domain Seed Exposure for LLM Research Ideation
- Out of the Shadows: Exploring a Latent Space for Neural Network Verification
- Formal Verification for Neural Networks with General Nonlinearities via Branch-and-Bound
- ModelVerification.jl: A Comprehensive Toolbox for Formally Verifying Deep Neural Networks
- Compositional Neural Network Verification via Assume-Guarantee Reasoning
- Reluplex: An Efficient SMT Solver for Verifying Deep Neural Networks
- Abstraction-Based Proof Production in Formal Verification of Neural Networks (Extended Abstract)