Portable Certificates: Verified Neural Networks That Stay Verified When the Scheduler Moves Them

Infrastructure-agnostic orchestrators rest on one promise: the same program can run on a laptop, a Slurm cluster, a Kubernetes pod or a cloud GPU, and the scheduler can treat those machines as interchangeable. Formal verification of neural networks makes a different promise: a mathematical proof that a network behaves safely on every input in a region. These two promises conflict. Verifiers prove properties of the network over real numbers. Each machine, however, computes with its own floating-point precision and its own order of additions, and floating-point addition is not associative, so different orders give slightly different answers. No Soundness in the Real World exploits this gap directly. The authors plant tiny "detector" neurons that fire only under one precision or one summation order. Every verifier they tested still certified the network as robust, at about 97% robust accuracy, while the deployed accuracy fell to 0.11%. In other words, a scheduler that freely moves a "verified" model between backends can silently throw away its guarantee.

We propose making certificates portable by stating where they hold. A verifier would emit a certificate parameterized by an arithmetic envelope: a short, machine-checkable description of the arithmetic behaviors the proof covers, such as minimum precision, whether reduced-precision tensor-core modes are allowed, and the maximum depth of the addition tree. Inside the bound propagation, the verifier adds sound rounding-error terms for that envelope. The orchestrator stores the envelope with the model and dispatches the model only to backends whose declared and probed arithmetic lies inside it. The research question is whether such envelope-parametric certificates can be sound against the known cross-platform attacks while remaining tight enough to certify nearly as much as real-arithmetic verification, and how much placement freedom each tier of envelope buys.

Core Claim

Rounding error in a dot product can be bounded without knowing the order of additions. For a length-$n$ dot product computed with unit roundoff $u$ (half the gap between adjacent floats at the working precision), the computed value satisfies

$$|\mathrm{fl}(w^\top x) - w^\top x| \le \gamma_k \, |w|^\top |x|, \qquad \gamma_k = \frac{k u}{1 - k u},$$

where $k = n$ for an arbitrary summation order and $k = \lceil \log_2 n \rceil$ when the backend promises a balanced reduction tree. This is the standard forward error analysis of summation. Its usefulness here is that the bound holds for every order within a class, so an adversary who chooses the order cannot escape it. Folding this term into each layer's linear bounds turns a real-arithmetic proof into a proof about a whole family of executions. Tiering the envelope by $k$ and $u$ yields a ladder of certificates: a loose one valid "anywhere with fp32 or better", and tighter ones valid only on tree-reducing backends or only in fp64. The orchestrator's job then changes from finding a free GPU to finding a free GPU inside the certificate's envelope.

This differs from the closest prior work as follows. GPUPoly already uses interval arithmetic in custom kernels, but to keep the verifier's own computation sound on its own GPU. It does not model the floating-point behavior of the deployed network across other machines. Szász et al. diagnose the failure but offer no verifier or execution system that closes it. Orchestrators such as Parsl, which separates application logic from pluggable executors and resource providers, and TOSCA-based platforms such as INDIGO-DataCloud, describe resources only as core counts, memory and accelerator type. Our proposal reuses Parsl's executor/provider split as its method substrate and adds an arithmetic descriptor to each provider.

Research Program

The first component is an envelope-aware bound propagator built on α,β-CROWN, the tool that won both VNN-COMP 2023 and VNN-COMP 2024. We chose this base because Beta-CROWN folds branching constraints into a differentiable dual that runs on GPUs. Adding per-neuron interval terms of the form above keeps that structure intact. The rounding term depends on $|x|$, which the propagator already bounds at each layer, so it costs one extra elementwise pass per layer. Activation functions, bias additions and fused multiply-adds receive their own small terms. Reduced-precision modes such as TF32 or bf16 accumulation change $u$ and are encoded as separate envelope tiers.

The second component is the portable certificate format and the placement check. A certificate records the property, the model hash and the envelope $(u, k, \text{allowed fused ops})$. Each orchestrator provider carries a descriptor of its arithmetic. The descriptor is declared by the operator and cross-checked by short probe kernels that detect precision mode and reduction behavior. Probes can show that a backend violates its declaration but cannot prove compliance, and we will report that limit plainly. Dispatch then becomes a constrained matching problem. A model may run only where descriptor ⊆ envelope. When no backend qualifies, the orchestrator either queues the model or triggers re-verification under a looser tier.

The third component is an empirical study of the trade-off between tightness and freedom. For each benchmark we will measure how verified accuracy falls as the envelope widens. We will also measure how much of a realistic heterogeneous pool each tier admits: CPU BLAS in fp32 and fp64, GPUs with and without TF32, and different batch sizes. Monotonicity specifications from NN4SysBench are a particularly sharp test. A learned database index that is monotone over the reals can break monotonicity through rounding between nearby keys, so floating-point effects matter in exactly the regime where systems deploy these models. The benchmark also offers the dual-model construction for encoding monotonicity, which we reuse.

Baselines

The naive reference point is real-arithmetic α,β-CROWN run unchanged, with its certificate treated as valid on every backend. This is how verified models are used today. It serves both as the upper bound on verified accuracy and as the baseline that should fail the soundness test. The file reports that tested verifiers, β-CROWN among them, reported about 97% robust accuracy on Szász et al.'s order-dependent attack networks while true accuracy was near zero, and 0.11% under the precision attack. We will reproduce that failure on the same detector-injected MNIST networks before claiming to fix it.

The strongest competitor on verification strength is α,β-CROWN itself. On the CIFAR-10 Base model, ABONN reports 32 instances solved by α,β-CROWN against ABONN's 106. ABONN changes search order, not soundness, so it is complementary rather than competing, and we will also run envelope-aware ABONN. For VNN-COMP verified-accuracy totals there is no reported result found on Lacuna for per-tool scores. We will therefore rerun α,β-CROWN ourselves under VNN-COMP-style per-instance timeouts on identical hardware, with identical branching heuristics and hyperparameters for our variant. The only difference will be the rounding terms.

The strongest competitor on soundness is a heuristic margin baseline: real-arithmetic verification that requires the output margin to exceed a fixed slack, such as a multiple of fp32 epsilon times the logit scale. This is what a practitioner would try first. To be fair, we will tune its slack on held-out clean networks to match our verified accuracy and then test both on the attack networks.

Two ablations isolate the key ingredient. The first uses only the worst-case envelope ($k = n$), with no tiers, to show what tiering buys. The second uses rounding terms only at the final layer instead of every layer, to show whether per-layer accounting is needed for soundness. Beating the baselines means zero false certifications on all of Szász et al.'s attack variants under any envelope that contains the target environment, while keeping verified accuracy within a stated fraction of real-arithmetic α,β-CROWN on standard benchmarks. We would treat a loss of more than about ten points under the fp32-anywhere tier as evidence that only the tighter tiers are practical.

Why not just…?

Why not just pin every verified model to one deterministic backend? This is the most serious alternative. If a deployment can promise one exact library, precision and batch size, and if deterministic kernels are enforced, then verifying under that exact semantics avoids envelopes altogether. It has two weaknesses. Real-arithmetic verifiers do not model even a single pinned float semantics, so pinning without our rounding terms still leaves the gap open. And Szász et al. show sensitivity to batch size and library, which pinning must freeze across every driver and library upgrade. Pinning also gives up exactly the fungibility that orchestration exists to provide. We will settle this by measuring how often "identical" pinned configurations in our pool actually agree bit-for-bit across versions, and by reporting the narrowest tier as the pinned case. If narrow-tier certificates cost almost nothing over wide ones, the honest conclusion is that tiers matter little and a single sound envelope suffices.

Why not just add a safety margin to the existing verifier? A fixed slack is unsound by construction, because the attack's detector neurons can be scaled to beat any fixed slack. A slack large enough to be safe everywhere is also looser than a per-layer bound that depends on the actual bounds on activation magnitudes. The tuned-margin baseline and the final-layer-only ablation test this directly.

Why not just test empirically on each target backend? Szász et al. show that the backdoors trigger only on specific orders and precisions, which ordinary testing never exercises. In their study, verifiers and accuracy tests alike reported high robustness while deployed accuracy collapsed. Testing will remain a sanity check on our probes, not a replacement for the certificate.

Why not just recheck outputs at runtime against an fp64 reference? Runtime monitoring roughly doubles inference cost and detects failures only after they happen. It is a reasonable complement, and we will report its overhead for comparison. It cannot supply the before-deployment guarantee that verification exists to give.

Proposed Experiments

The decisive check is soundness on the attack networks of Szász et al. These are MNIST classifiers with precision- and order-sensitive detectors, executed on PyTorch and Flux, CPU and GPU, and fp32 and fp64. For every envelope tier, we will count certificates issued for networks whose deployed accuracy inside that envelope collapses. The target is zero. We will also confirm that the orchestrator refuses to place each model on backends where its certificate does not hold.

The tightness experiments run on the MNIST and CIFAR-10 models used by Beta-CROWN and ABONN, on VNN-COMP 2023/2024 instances including ACAS Xu, and on NN4SysBench learned-index monotonicity and cardinality-estimation specifications using the shuyilinn/NN4Sys_Benchmark code. The metrics are verified accuracy or the fraction of specifications proven, plus wall-clock time per instance, reported per tier. One outcome would sharply falsify the approach: if the fp32-anywhere tier verifies almost nothing on CIFAR-10 or learned indexes while the narrow tiers recover near-baseline accuracy, then portability across arbitrary backends is not achievable with order-independent bounds. That result would itself be worth reporting, because it would mean orchestrators must expose reduction-order guarantees as a first-class resource.

The placement experiment uses a mixed pool that includes CPUs, GPUs with and without TF32, and varied batch sizes. It measures the fraction of the pool each certificate admits, and the queueing delay a certificate-constrained Parsl scheduler adds compared with unconstrained dispatch, on a stream of inference jobs.