Neural networks can now clean up noisy quantum computations. They read the noisy measured outputs of a circuit and predict the values an ideal, noise-free machine would have produced. These models are trained to be accurate on average, but real quantum processors drift in slow, correlated ways, so the cases that matter are the unlucky ones. The noise has memory: an over-rotation caused by a drifting control line on layer 3 is still there on layer 30. Adversarial training is the standard way to make a network hold up under worst-case input shifts. It trains against the most damaging perturbation found by an inner optimization loop. That loop usually multiplies training cost by an order of magnitude. Here it would be worse, because every inner step would require re-simulating noisy circuits.
This proposal starts from the fact that makes the noise hard, its memory, and uses it to make the adversarial search cheap. Noise with temporal memory is dominated by a few slow modes shared across all gates in a circuit, rather than by independent per-gate kicks. The worst-case perturbation therefore lives in a small subspace. We can precompute once how each circuit's measured features respond to that subspace, and then run the inner maximization entirely inside the neural network with no simulator calls. The claim is that this recovers most of the tail robustness of full adversarial training for a small fraction of its cost. It should also beat the cheap alternatives, including random augmentation drawn from the same drift family, on worst-case and high-percentile error.
Core Claim
The model we build on is QEMFormer from QEM-Bench. It treats a circuit as a directed acyclic graph (gates as nodes, qubit wires as edges) and reads it with a graph transformer plus an MLP. It also takes "noise probes", extra Pauli expectation values measured on the device to gauge its current state. It is trained purely by regression on average error and reports an RMSE of 0.025 on Trotterized circuits under incoherent noise. Nothing in the file tests how it behaves when the device drifts in a structured direction.
Physics work says such drift is the norm. Proctor et al. document low-frequency $1/f$ noise and drifting control signals in solid-state qubits. Shaw et al. show shot-to-shot laser jitter producing correlated errors across many operations on a 60-atom simulator. Hashim et al. argue that average infidelity can badly understate worst-case error when noise is coherent or non-Markovian. That is exactly the gap between an average RMSE and the behavior of a mitigator under an unlucky drift. These papers motivate the proposal.
The method comes from Markovian Embedding Procedures for Non-Markovian Stochastic Schrödinger Equations. That paper shows memory-bearing dynamics can be represented by adding a few auxiliary slow degrees of freedom. We borrow only the modeling consequence, which is that the memory is carried by a low-dimensional set of slow modes. We make no attempt to simulate the enlarged system.
Concretely, we parameterize drift on qubit $q$ at circuit layer $\ell$ out of $L$ layers as a coherent over-rotation plus dephasing strength whose deviation from nominal is
$$\delta_{q}(\ell) = \sum_{k=0}^{K-1} a_{q,k}\,\phi_k(\ell/L),$$
where the $\phi_k$ are the $K$ lowest-frequency cosine modes and $a_{q,k}$ are drift amplitudes. With $K$ around 3–5, this covers static offsets, linear ramps and slow oscillations, the shapes that $1/f$ spectra and control drift produce. The adversary chooses $a$ within a ball whose radius is set from characterization data. It is shared across all circuits executed in the same time window, because they experience the same device weather.
Let $x_i$ be the features of circuit $i$ (noisy expectation values plus noise probes). Let $J_i = \partial x_i / \partial a$ be the precomputed response of those features to the drift amplitudes, obtained once per circuit by simulation. Let $f_\theta$ be the mitigator and $y_i$ the ideal value. Training then solves
$$\min_\theta \sum_{w} \max_{\|a\|\le \rho} \sum_{i\in w} \big(f_\theta(x_i + J_i a) - y_i\big)^2,$$
where $w$ indexes time windows (minibatches of co-executed circuits) and $\rho$ is the drift budget.
The inner maximization touches only $nK$ numbers, with $n$ the qubit count, and costs only network backpropagation. Because drift is slow, the adversary's $a$ is carried over from one training step to the next and refined with one or two gradient steps rather than solved from scratch.
Research Program
The work has four pieces.
Drift simulator and response library. The first piece is a differentiable noisy-circuit simulator for the simulated QEM-Bench tiers that adds the drift model above. From it we build a library of per-circuit response matrices $J_i$. Directional derivatives in $K$ modes per qubit keep this to $O(nK)$ extra simulations per circuit. That cost is paid once and amortized over every training epoch.
Linearization audit. The second piece checks whether the linear response is accurate enough. We do this by re-simulating circuits under the adversary's final $a$ and comparing the true feature shift to $J_i a$ across drift radii. Where the audit fails at large $\rho$, we add a single true re-simulation at the end of each epoch to correct the persistent adversary. We report how much that costs.
Training variants. The third piece is the training itself. QEMFormer is trained with the drift-subspace adversary. A lower-cost arm freezes a standard-trained QEMFormer and adversarially trains only a small set of prefix tokens, in the manner of Robustness Tokens. That paper froze a vision transformer and trained only prepended tokens under image attacks; we test whether the same trick works on circuit graphs under physical drift rather than pixel perturbations.
Evaluation protocol. The fourth piece is an evaluation that separates average accuracy from tail accuracy, mirroring the average-versus-worst-case distinction in Hashim et al..
Baselines
The naive reference point is QEMFormer trained by standard regression exactly as in QEM-Bench. Its reported figure is RMSE 0.025 on Trotterized circuits with incoherent noise. We retrain it with the published setup to confirm we reproduce roughly that value before any comparison. Beating it means lower 95th-percentile error and lower worst-case error over the drift ball at matched in-distribution RMSE, within about 10% of its reproduced value.
The traditional mitigation baselines are Zero-Noise Extrapolation and Clifford Data Regression, run on the same circuits and shot budget. QEM-Bench reports that QEMFormer beat both. No reported numeric result was found on Lacuna for ZNE or CDR on these datasets, so we report our own runs. Direct Analysis of Zero-Noise Extrapolation gives reason to expect ZNE's polynomial fit to degrade when drift breaks the assumed noise scaling. We will measure whether ZNE's tail error under drift is actually worse than its average error, since that is the regime where it could conceivably be more stable than a learned model.
The strongest cheap competitor is structured random augmentation. It trains QEMFormer on features shifted by $J_i a$, with $a$ drawn at random from the same low-frequency drift family and radius, rather than adversarially. It uses the same response library, epochs and tuning budget as our method. It isolates whether the adversary matters or whether the drift parameterization alone does the work.
A weaker augmentation variant uses independent Gaussian jitter on gate angles and noise probes. It tests whether the low-frequency structure matters.
The strongest expensive competitor is full adversarial training. Here the adversary perturbs each gate's noise parameters independently, per sample, with multi-step projected gradient descent through the differentiable simulator. It gets the same total drift budget measured in the same norm and is tuned over step count and step size with the same number of trials. We also run its single-step version, because single-step adversarial training is known to collapse against multi-step attacks, the problem called catastrophic overfitting.
Two ablations isolate the key ingredients. One replaces the shared-per-window adversary with a per-sample adversary in the same subspace. The other replaces the persistent warm-started adversary with a fresh multi-step one each iteration.
Beating the expensive baseline means reaching within a small margin of its worst-case error at a fraction of its wall-clock cost. We report GPU hours and simulator calls. Beating structured random augmentation means a clear tail-error gap at matched average RMSE. If that gap is absent, the proposal's claim fails.
Why not just…?
Why not just augment with random drift from the same physical family? This is the real threat, and the experiments are built around it. Random samples from a low-dimensional ball cover it reasonably well when the dimension is tiny. The adversary's advantage should therefore grow with $nK$ and shrink as the ball's volume becomes easy to cover. We sweep $n$ (qubit count across tiers) and $K$ and report where, if anywhere, the curves separate. If random drift augmentation matches our tail error everywhere, we will say so. The contribution then reduces to the drift-subspace representation and its cheap response library, which is still useful but is not an adversarial-training result.
Why not just fine-tune or recalibrate on fresh data when the device drifts? Recalibration handles drift after it is detected. It does nothing for the circuits run before the next calibration, and characterization itself consumes processor time. Park et al. also show that standard characterization misreads noise near zero frequency, where drift lives. The experiment is a temporal split: models are trained on early data and evaluated on later windows, with and without a fine-tuning step allowed on a small fresh calibration set. The comparison is how much fresh data fine-tuning needs to match a drift-robust model with none.
Why not just run standard full adversarial training? It is the most thorough option, and it is included as a baseline. Every inner step requires re-simulating noisy circuits and backpropagating through a graph transformer. The adversarial-training literature in the file shows this kind of inner loop becoming impractical even in cheaper domains; Towards Improving Adversarial Training of NLP Models reports thousands of forward passes per text example. The question is not whether full adversarial training is more robust, since it may be. The question is whether the subspace version gets most of the benefit at a small fraction of the cost. The cost–robustness curve settles that.
Why not just use Zero-Noise Extrapolation and skip learning altogether? QEM-Bench found learned mitigators more accurate than ZNE and CDR on average. ZNE also needs repeated hardware runs of each circuit. We include ZNE tail error under drift so this is decided by measurement rather than by argument.
Proposed Experiments
Simulated tiers. On the Standard and Advanced tiers of QEM-Bench (Trotterized dynamics, QAOA and random circuits), we inject drift from the low-frequency model at several radii. For every method we report average RMSE, 95th-percentile error and worst-case error. Worst-case error is found by a strong evaluation attack: many restarts and many steps, with true re-simulation rather than the linear response, so the evaluator is never weaker than the trainer. The Advanced tier adds a harder test, whether drift robustness survives the shallow-to-deep generalization shift. Deeper circuits give slow modes more layers over which to accumulate coherently.
Decisive checks. Three results decide the proposal. The first is a tail-error gap between drift-subspace adversarial training and structured random augmentation at matched average RMSE; without it the adversarial claim fails. The second is a cost ratio of at least several-fold relative to full per-gate adversarial training at comparable worst-case error. The third is that the linearization audit shows the response model is accurate enough at the chosen radius.
Robustness to model misspecification. A secondary check draws evaluation drift from a family the model did not train on, for example higher-frequency components. This tests whether the low-frequency assumption helps on its target and costs robustness off-target.
Hardware tier. On the Large-Scale tier (IBM Kyiv and IBM Brisbane data), adversarial evaluation is impossible because we cannot re-run the hardware. Instead we evaluate on held-out acquisition windows, if the released data carries timestamps, and compare error spread across windows between regular and drift-robust models. If timestamps are unavailable, the hardware tier supports only an in-distribution sanity check that robustness did not hurt average accuracy. We will state that limitation rather than overclaim.
References
- QEM-Bench: Benchmarking Learning-based Quantum Error Mitigation and QEMFormer as a Multi-ranged Context Learning Baseline
- Scalable Randomized Benchmarking of Quantum Computers Using Mirror Circuits
- Benchmarking highly entangled states on a 60-atom analogue quantum simulator
- Benchmarking quantum logic operations relative to thresholds for fault tolerance
- Markovian embedding procedures for non-Markovian stochastic Schrödinger equations
- Robustness Tokens: Towards Adversarial Robustness of Transformers
- Direct Analysis of Zero-Noise Extrapolation: Polynomial Methods, Error Bounds, and Simultaneous Physical-Algorithmic Error Mitigation
- Efficient continuous-wave noise spectroscopy beyond weak coupling
- Towards Improving Adversarial Training of NLP Models