Analog in-memory accelerators are chips that perform matrix multiplication directly inside arrays of memory cells whose electrical conductances store the weights. They are projected to be far more energy-efficient than GPUs, and if they reach the cloud, clients will pay a provider to run a neural network on one. Today such a client has no way to check what came back. Classical verifiable-computation checks require exact equality. Freivalds' test, for example, confirms a matrix product by multiplying both sides by a random vector, and honest analog hardware fails it on every query because its outputs are always slightly noisy. Dropping verification hands a dishonest provider a convenient excuse: any shortcut, such as a lower-rank weight matrix, pruned layers, or a cheap 4-bit digital emulation, can be passed off as "analog noise."
We propose replacing the exact equality with a statistical test whose acceptance region comes from a device noise model, and measuring what that buys in adversarial terms. The quantity of interest is the cheating headroom: how much compute an adversary that knows the test can save while still passing at a fixed detection rate. The test is only as good as its noise model, and here the simulation-to-silicon gap stops being a nuisance and becomes the central difficulty. If the envelope is fitted in a simulator and is too tight for real silicon, honest chips get rejected. If it is loose enough to be safe, the headroom grows. The core claim is that a three-part protocol can make the headroom small without rejecting honest silicon. The provider commits once to its programmed weights, which it reads back after writing them to the chip. Each query is then checked against that commitment using only the noise that is fresh on each read. Finally, the noise envelope is calibrated against measurements from physical silicon rather than taken from the simulator.
Where this sits
The verification side supplies the method. Slalom checks GPU-computed linear layers from inside a trusted enclave using Freivalds' test. For exact fixed-point arithmetic it reports end-to-end throughput gains of "6x to 20x" over running inside the enclave. It assumes deterministic accelerator output, which is exactly the assumption analog hardware breaks. SafetyNets and the Zebra system in Verifiable ASICs work over exact finite fields. Verifiable Computing for Approximate Computation extends interactive proofs to deterministic fixed-point rounding over integer rings. All three treat approximation as a deterministic function. Analog noise is stochastic and partly persistent, so none of them can represent it.
The closest bridge is Optimistic Verifiable Training by Controlling Hardware Nondeterminism. It identified the "hardware variation as plausible deniability" attack on GPUs and removed it by forcing bit-exact replication through logged rounding decisions. That paper motivates this one, and it also marks the limit of its own approach. Bit-exactness is achievable for IEEE floating point, but no log can make two analog reads agree. We therefore do the opposite: we accept nondeterminism and bound how much of it an adversary can exploit.
The hardware side supplies the noise models and the evidence for the gap. AIHWKit and Rasch et al.'s hardware-aware training model several effects of phase-change memory arrays: programming noise, read noise, conductance drift, voltage drop along the array wires, and quantization error in the converters between digital and analog signals. Rasch et al. report that 5 of 11 workloads reach accuracy within 1% of FP32, and that the models remain stable over a simulated year of drift. Dynamic Symmetric Point Tracking shows that device state keeps evolving and that static calibration is impractical, which constrains our design: the commitment must be refreshed over time. Evidence from digital systems (Walker et al., GuaranTEE) shows that simulators routinely misstate physical behavior. We take this as a warning that a simulator-fitted envelope should not be trusted without a silicon check. The file reports no work that verifies the integrity of computation on analog hardware: no reported result found on Lacuna for verified analog in-memory inference.
Core Claim
Honest analog error on one layer, $\tilde y = Wx + e$, splits into two parts. The first is a persistent part $E_{\text{prog}}x$, where $E_{\text{prog}}$ is the fixed programming error on this particular chip. The second is a fresh part made up of read noise and converter error, with input-dependent covariance $\Sigma(x)$. A scalar tolerance has to absorb both parts at their worst case, and that slack is where cheating hides.
The protocol removes the persistent part first. After programming, the provider commits (by Merkle hash, as in the optimistic-training work) to the read-back effective weights $\tilde W$. The client checks once that $\tilde W$ is close to $W$, at a one-time cost of $O(n^2)$ that is amortized over all later queries. The client also precomputes $s_j^\top \tilde W$ for $k$ secret random probe vectors $s_j$.
Each query is then checked with
$$ T(x,\tilde y)=\sum_{j=1}^{k}\frac{\big(s_j^\top \tilde y - (s_j^\top \tilde W)\,x\big)^2}{s_j^\top \Sigma(x)\, s_j}, $$
accepting when $T$ is below the $1-\alpha$ quantile of a chi-square distribution with $k$ degrees of freedom. For each layer this costs $O(kn)$ instead of the $O(n^2)$ needed to recompute the product. The probes are secret, so a deviation $d$ cannot be steered into directions the test ignores. Its detectability then scales roughly with $\|d\|^2/\mathrm{tr}\,\Sigma(x)$, which means only the fresh-noise budget, not the full error budget, is available for hiding.
We define headroom $H$ as the largest fraction of multiply-accumulate operations (or energy) that any cheat in a given family saves while being accepted with probability at least $1-\delta$.
We do not claim to prove which physical substrate ran the computation. A provider that adds synthetic noise to a digital emulation and stays inside the envelope has delivered analog-quality output. The guarantee is about the quality of the output, and we state it that way.
Research Program
The work has three parts.
The first is fitting $\Sigma(x)$. We fit it per layer as a function of input magnitude and of the conductance distribution, starting from the AIHWKit phase-change memory models, and then re-fit it on physical silicon. The physical platform is the IBM Fusion chip that Le Gallo et al. used for hardware validation, accessed through the cloud service that paper describes.
The second is drift. We treat it with periodic recommitment, and we study how often recommitment must happen under AIHWKit's drift and global drift-compensation models before honest outputs leave the envelope.
The third is attacks, which we build at two levels of strength. The simpler level consists of fixed cheat families: truncating the weight matrix to low rank, pruning, digital emulation at reduced bit-width, skipping layers, and processing a subsampled batch. Each comes with optional synthetic noise added to mimic the honest statistics. The stronger level is an adaptive adversary. It knows the test and the form of $\Sigma$, but not the probes, and it optimizes its deviation to maximize savings subject to an estimated acceptance rate.
Baselines
The naive reference point is exact Freivalds as used in Slalom. We run it unchanged on honest simulated and physical analog outputs. We expect a false-rejection rate near 100%. Showing this establishes that analog hardware needs a different check, rather than merely asserting it. Slalom's reported "over 60x" verification speedup for individual convolution layers sets the cost target our check should approach.
The strongest simple competitor is Freivalds with a tolerance: accept when the probe residual is within $\tau$ times the norm of the output, with $\tau$ tuned separately for each layer. It gets the same probes, the same calibration data, and the same budget for tuning against a target false-rejection rate as our method. It beats our method if, at equal false rejection, its headroom against the adaptive adversary is within noise of ours.
A second competitor is spot re-execution. The client recomputes a random fraction of queries digitally and accepts if they agree within a tuned tolerance, given the same total verifier compute as our test.
A third is a canary audit, which checks task accuracy on a hidden labeled set mixed into the query stream.
Two ablations isolate the key ingredients. One uses the calibrated statistic without the weight commitment, so the persistent error stays inside $\Sigma$. The other uses the commitment but fits $\Sigma$ only in simulation. We call the protocol better if, at equal false rejection (at most 1% on silicon), it cuts headroom by a large factor relative to tuned-tolerance Freivalds, and if the best evading cheat costs measurably less accuracy.
Why not just…?
Why not just use Freivalds with a well-tuned tolerance? This is the real threat. Honest analog error is heteroscedastic: it grows with input magnitude and with conductance, and it jumps when the converters clip. A single threshold must therefore be set for the worst case, leaving slack on typical inputs, and it also absorbs persistent programming error that the commitment removes. Neither argument is proof. The tuned-tolerance baseline and the no-commitment ablation measure the difference directly. If they match our method, the honest conclusion is that a scalar tolerance suffices, and the contribution narrows to the headroom measurement and its calibration on silicon.
Why not just re-execute a random sample of queries? Re-executing one layer on one query costs $O(n^2)$, against $O(kn)$ for the probe check, so a fixed budget covers far fewer queries. Cormode et al. note that clients lack the compute to make re-execution cheap. Re-execution also still needs a tolerance, so it inherits the scalar-threshold problem. The equal-budget comparison will show whether intermittent cheating slips through.
Why not just audit accuracy with canaries? Canaries catch only cheats that lower accuracy on the canary distribution, and only after many queries. An adversary that recognizes canaries, or that cheats only on hard inputs, evades them. We include the canary audit in the comparison and report detection latency, measured in queries until detection, alongside headroom.
Why not just use SNARKs or bit-exact replication? Both require a deterministic computation to prove. Optimistic verifiable training achieves exact replication only by logging rounding decisions in IEEE arithmetic, and analog reads have no rounding decision to log. Neither approach can be run on this hardware, so we argue the point rather than test it.
Proposed Experiments
In simulation we use AIHWKit phase-change memory arrays on ResNet-32 / CIFAR-10, following the AIHWKit paper. We also use hardware-aware-trained ImageNet ResNets and BERT from Rasch et al.'s workload suite. We report false rejection on honest runs across a simulated year of drift, and headroom for each cheat family and for the adaptive adversary, at $\delta = 0.01$ and $k$ from 1 to 32.
The decisive check concerns the simulation-to-silicon gap. We fit $\Sigma$ in AIHWKit and apply it unchanged to outputs from the Fusion chip. We then refit it on held-out silicon measurements and compare false rejection and headroom between the two fits. If the simulator-fitted envelope rejects honest silicon at a high rate, or must be widened enough that headroom approaches that of tuned-tolerance Freivalds, then calibrating on silicon is necessary rather than optional.
The second decisive check is the adaptive adversary. If it achieves large savings (for example, emulating the computation at reduced rank) while staying under the threshold with less than 1% accuracy loss, the guarantee is weaker than claimed, and we report that bound as the result.
References
- Slalom: Fast, Verifiable and Private Execution of Neural Networks in Trusted Hardware
- SafetyNets: Verifiable Execution of Deep Neural Networks on an Untrusted Cloud
- Verifiable ASICs
- Verifiable Computing for Approximate Computation
- Optimistic Verifiable Training by Controlling Hardware Nondeterminism
- Using the IBM analog in-memory hardware acceleration kit for neural network training and inference
- Hardware-aware training for large-scale and diverse deep learning inference workloads using in-memory computing-based accelerators
- Dynamic Symmetric Point Tracking: Tackling Non-ideal Reference in Analog In-memory Training
- Accurate and stable empirical CPU power modelling for multi- and many-core systems
- GuaranTEE: Towards Attestable and Private ML with CCA
- Verifying Computations with Streaming Interactive Proofs