Machine-learned interatomic potentials are neural networks that predict the forces between atoms at close to quantum-chemistry accuracy for a small fraction of the cost. They are now trained in a closed loop. A cheap simulation runs with the current network, the network's own uncertainty flags configurations it has not seen, an expensive quantum calculation (density functional theory, DFT) labels those configurations, and the network is retrained. More and more of this loop runs on rented cloud hardware. That creates an incentive problem nobody in the materials literature has addressed. The provider bills for DFT calls and pays for compute, so it profits by quietly reporting low uncertainty and skipping the expensive labels, or by reporting high uncertainty and billing for labels nobody needed. A potential trained on a loop that skipped its rare, high-uncertainty configurations looks fine on equilibrium data and then fails, sometimes violently, in exactly the reactive regimes it was meant to learn.
We propose to make this loop auditable without cryptographic proofs. The provider commits, with a Merkle hash tree (a tamper-evident digest that lets the client later demand any single record), to every simulation frame, including positions, velocities, forces, reported uncertainty, and the decision to call or skip DFT. Only after that commitment does the client choose which frames to audit. For each audited frame it recomputes one simulation step and one uncertainty evaluation from the committed state, and accepts if they match within a floating-point tolerance. The new ingredient is how frames are chosen. Cheating that saves money concentrates on the rare frames that should have triggered DFT, so uniform spot-checks mostly miss it. The client therefore samples frames in proportion to a cheap uncertainty proxy that it computes itself and that the provider cannot manipulate. In this design, uncertainty quantification guides where verification effort is spent.
Core Claim
Our claim is that an audit rule mixing uniform sampling with sampling weighted by a client-side novelty proxy can do three things for outsourced active learning. It should detect uncertainty under-reporting at a client cost of a few percent of the provider's compute, a cost where uniform spot-checking has low detection power. It should keep false alarms near zero on honest heterogeneous GPUs, because each check starts from a committed state rather than replaying a chaotic trajectory. And it should bound how much a cheater who knows the protocol can save by hiding in the proxy's blind spots. If the provider corrupts a set $B$ of the $T$ committed frames and the client draws $m$ audits independently from a distribution $q$ chosen after commitment, the detection probability is
$$ P_{\text{detect}} = 1 - \big(1 - q(B)\big)^{m}, $$
where $q(B)$ is the total sampling mass on corrupted frames. Uniform sampling gives $q(B) = |B|/T$, which is tiny when the cheat targets the roughly one-in-a-thousand frames that cross the uncertainty threshold. Proxy weighting raises $q(B)$ by a factor equal to how much the proxy over-weights truly uncertain frames. That factor is an empirical quantity, and measuring it is the heart of the project.
Why this gap, and why this design
The prover-overhead literature explains why we do not simply prove the simulation. Proof generation runs three to seven orders of magnitude slower than native execution, as documented by Geppetto and Buffet. Those systems introduced modular circuits and loop flattening, and Buffet's flattening needs a static bound on loop length. That is a poor fit for trajectories that end whenever uncertainty spikes. Linear-time provers such as HyperPianist improve the asymptotics but not the constant gap. Equivariant potentials are built from distances, radial basis functions, and smooth nonlinearities, which are the transcendental operations that Scaling Verifiable Machine Learning identifies as costing thousands of constraints each. Confidential Guardian reports zero-knowledge calibration proofs taking about 333 seconds per data point for a ResNet-50. Scaled to millions of molecular dynamics steps, that is hopeless. Together these works constrain the design and rule out per-step proofs.
The verifiable-outsourcing literature supplies most of the method. Outsourcing Computation: the Minimal Refereed Mechanism shows that committing to an execution tableau with Merkle trees lets a verifier check a single step and pay only logarithmic overhead. However, it needs two non-colluding provers and bit-exact agreement, and TOPLOC shows that bit-exact agreement fails across GPU architectures. TOPLOC's answer is to hash top-k activations, which suits language models but discards the small, distributed force components that matter for an energy surface. Slalom and SafetyNets verify inference cheaply, but only for static networks with linear-heavy or quadratic-activation structure. We keep the commit-then-check-one-step idea and change three things. We use one provider plus a client instead of two providers. We compare with a tolerance instead of exact hashes, and this is sound because single-step recomputation error does not compound the way chaotic divergence does over a full trajectory. Finally, we sample frames non-uniformly, steered by uncertainty.
The closest work on the trust side is Confidential Guardian, which uses zero-knowledge proofs to show that a classifier's calibration error stays below a threshold. That motivates our setting: uncertainty reports can be weaponized. It differs from ours in three ways. It addresses classification rather than force regression, it certifies an aggregate calibration statistic rather than per-frame trigger decisions inside a loop, and it pays full proof cost. Cormode et al. and Hickey and Cormode formalize why cloud providers take shortcuts such as early halting and subsampling. We take their threat model as given.
The active-learning side supplies the uncertainty machinery. The evidential potential of Evidential deep learning for interatomic potentials (eIP) produces per-atom, per-direction force uncertainty in a single forward pass, about 4× faster than an ensemble. That makes the client's recheck of a single frame cheap. Learning a reactive potential for silica-water through uncertainty attribution differentiates ensemble variance with respect to atomic positions to cut out small high-uncertainty clusters for DFT. In an outsourced setting this creates another unverified decision, the cluster boundary, which we add to the committed record. The review by Gkeka et al. explains why errors concentrate at rare transition states, which is why the cheat we target is concentrated rather than uniform.
Research Program
The protocol runs per active-learning round. The client sends the current potential's weights and their hash. Weights are small, so the client keeps a copy; verifying the retraining step itself is out of scope here. The provider runs exploratory molecular dynamics, records each frame with its reported uncertainty and trigger decision, runs DFT on triggered frames or clusters, and commits a Merkle root over everything. The client then draws a fresh random seed. The seed selects the proxy variant and the audit sample, so the provider cannot anticipate either before committing.
Audits come in three kinds. A step audit recomputes forces and one integration step from a committed frame and compares against the next committed frame. This catches skipped steps, inflated timesteps, and silent precision downgrades, which are spread across the whole trajectory, so uniform sampling suffices. An uncertainty audit recomputes eIP uncertainty at a committed frame and checks the reported value and the trigger decision. This is where proxy weighting matters. A label audit re-runs DFT on a small fraction of triggered frames, either locally or at a second provider, which catches fabricated labels and over-reporting. Triggered frames are few, so this audit can be dense.
The proxy must be cheap and computed entirely by the client. We will compare three candidates. The first is the nearest-neighbor distance of each atom's environment, in the feature space of a small frozen network, to the client's training set. The second is the disagreement between two tiny distilled potentials. The third is a randomized mixture of the two, selected by the post-commitment seed. The proxy runs on positions only, at a stride of k frames. Uncertainty varies smoothly along a trajectory, so lying across one high-uncertainty excursion means lying across a window of frames, and stride sampling still lands in it. The final audit distribution mixes uniform and proxy-weighted mass. The mixing weight trades off coverage of uniform cheats against concentrated ones, and we will tune it on held-out attack scenarios.
The tolerance needs calibration, because a check that fires on honest hardware disagreement is worthless. We will measure the distribution of single-step force and position discrepancies for honest eIP runs across GPU generations and precisions. We will set the tolerance at a high quantile of that honest distribution and verify that it still separates fp32 runs from downgraded ones.
Baselines
The naive reference point is no verification. The provider's reports are taken at face value, as in every published active-learning loop. Under this baseline we measure how much a cheating provider saves and how much the final potential degrades. That quantifies the stakes. If an undetected under-reporting attack barely hurts the final potential, the problem is not worth solving, and we will report that.
The strongest practical competitor is uniform random spot-checking at the same client budget: the same commitment, the same step and uncertainty audits, the same tolerance, but frames drawn uniformly. It is the strongest competitor because it is what an engineer would build first, it costs exactly what our method costs, and it already handles uniform cheats well. We give it the same audit count, the same hardware, and the same tolerance calibration. Our method beats it if, at a client budget of a few percent of provider compute, it detects concentrated under-reporting with substantially higher probability at matched false-positive rates. A small edge is not enough: the curve of detection probability against audit budget must move by a margin that changes how many audits a client needs.
The strongest existing verification method is the dual-provider Merkle refereed mechanism of MRM. For fairness we will run it with tolerance-based rather than exact-hash comparison of rows, and on two different GPU types. It roughly doubles provider cost, and its arbitration step touches one frame. We will compare total cost, the sum of provider plus client compute, at matched detection. Our method beats it if it reaches comparable detection at well under twice the honest baseline cost. As a ceiling, full client re-execution gives perfect detection at 100% client cost. For proof-based verification of an equivariant potential, we found no reported result on Lacuna for proving MLIP inference or molecular dynamics. We will cite the 10³–10⁷ overhead range from Geppetto and Buffet rather than invent a figure. We may build a small prototype circuit for one PaiNN layer to obtain a measured number.
Two ablations isolate the key ingredient. One draws audit weights from the provider's own reported uncertainty instead of the client proxy. We expect this to fail against under-reporting, because the cheater controls the weights. The other removes the post-commitment seed, so the proxy is fixed and known in advance, which measures how much secrecy contributes. For the uncertainty model itself, eIP's reported Spearman correlation between force error and uncertainty of up to 0.86 on ISO17 Evidential deep learning for interatomic potentials is the reference quality our proxy must approach to be a useful sampler. We will measure the proxy against that number and against the true eIP uncertainty.
Why not just…?
Why not just spot-check uniformly at random? This is the real threat, and the experiments are designed to settle it. A provider who wants to skip DFT only needs to lie on frames that cross the threshold, typically a tiny fraction. Uniform auditing then puts almost no mass on them, which follows directly from the detection equation with $q(B) = |B|/T$. If our measurements instead show that triggers are frequent, or that cheats contaminate long windows, uniform sampling may be nearly as good. We will then report that the simpler method suffices and the proxy is unnecessary.
Why not let the client run the cheap proxy and make the DFT trigger decisions itself, so no uncertainty claim needs verifying? This is the second real threat. If a cheap descriptor-distance proxy were as good a trigger as eIP, the whole outsourced uncertainty step would be redundant. We test it directly. We run the full active-learning loop with proxy-triggered labeling and with eIP-triggered labeling on silica-water and silica glass, and compare final force error and simulation stability at equal DFT budgets. The working hypothesis is that a proxy weak enough to be cheap is a good triage signal, since it only needs to rank frames roughly, but a poor trigger, which needs calibrated thresholds. If proxy-triggered loops match eIP-triggered loops, we will say so and recommend the simpler client-side design.
Why not just use two providers and compare, as in the refereed mechanism? It works, and with tolerance-based comparison it avoids false disputes. But it pays a second full provider run on every trajectory, for every round, even when nobody cheats. Our comparison at matched detection reports total cost. Two providers is the right choice for clients who can afford it, and our method targets those who cannot.
Why not run everything in a hardware enclave? Enclaves are CPU-bound and memory-limited. Slalom reports 6× to 20× throughput gains from moving linear layers out of the enclave onto an untrusted GPU. In message-passing potentials, much of the work is nonlinear geometric computation that Slalom would leave inside the enclave, so the penalty would be worse. Enclaves also do not address fabricated DFT labels computed elsewhere.
Proposed Experiments
We use three systems from the file: ISO17 molecular dynamics, silica glass, and the silica-water reactive system. For silica-water, the reference force error of 1.32 kcal/mol/Å reported in Learning a reactive potential for silica-water through uncertainty attribution anchors what an honest loop should reach. The provider runs eIP-driven active learning, plus an ensemble variant for silica-water with cluster extraction. We simulate five provider behaviors: honest; under-reporting on threshold-crossing frames; precision downgrade; timestep inflation; and over-reporting with fabricated triggers. We add an adaptive cheater who knows the candidate proxies and lies only where all of them score low.
The decisive check has three parts. First, on silica-water at a client budget of a few percent of provider compute, proxy-weighted mixture auditing must detect concentrated under-reporting with probability near one where uniform auditing does not, while honest runs across two GPU generations produce essentially no false alarms. Second, for the adaptive cheater, we report the largest fraction of DFT cost it can avoid while keeping detection probability below 1%. That number is the protocol's honest security margin. Third, we measure the cost of undetected cheating: the force error and simulation stability of potentials trained under the most profitable undetected attack, against the honest loop. That shows whether the residual blind spots matter physically.
The project fails cleanly if any of the following holds. Honest single-step discrepancies across hardware overlap with precision-downgrade discrepancies, so no tolerance separates them. The proxy's lift over uniform sampling on truly uncertain frames is near one. Or proxy-triggered loops match eIP-triggered ones. Each failure points to a simpler protocol, and we will report which one.
References
- Geppetto: Versatile Verifiable Computation
- Efficient RAM and control flow in verifiable outsourced computation
- HyperPianist: Pianist with Linear-Time Prover via Fully Distributed HyperPlonk
- A survey of zero-knowledge proof based verifiable machine learning
- Outsourcing Computation: The Minimal Refereed Mechanism
- TOPLOC: A Locality Sensitive Hashing Scheme for Trustless Verifiable Inference
- Slalom: Fast, Verifiable and Private Execution of Neural Networks in Trusted Hardware
- SafetyNets: Verifiable Execution of Deep Neural Networks on an Untrusted Cloud
- Confidential Guardian: Cryptographically Prohibiting the Abuse of Model Abstention
- Verifying Computations with Streaming Interactive Proofs
- Cheap Checking for Cloud Computing: Statistical Analysis via Annotated Data Streams
- Evidential deep learning for interatomic potentials
- Learning a reactive potential for silica-water through uncertainty attribution
- Machine learning force fields and coarse-grained variables in molecular\n dynamics: application to materials and biological systems