Today's quantum computers are too noisy to run most algorithms, so the leading near-term approach is a hybrid loop where a quantum machine evaluates a candidate circuit, an ordinary classical optimizer compares the results and adjusts, and the two take turns for hundreds of iterations; that loop rests on an assumption nobody had examined — that the machine behaves the same way while it is comparing candidates — and it does not, because quantum hardware drifts from minute to minute as microscopic defects couple and decouple from the qubits, so a genuinely good candidate can measure badly and a genuinely bad one can measure well; the optimizer then confidently walks in the wrong direction, and the paper shows a real 24-hour run where iteration 500 is no better than iteration 100; this paper (Chicago and IBM) fixes it without correcting anything — each round it quietly re-runs the PREVIOUS round's circuit as a control, uses the change to estimate how much the machine has drifted, and if the drift is large enough to have flipped whether a candidate looks better or worse, it simply throws that round away and tries again, improving results by 29 to 51 percent on six real IBM machines.
The argument in one glance
-
Problem
The optimizer compares candidates on a machine that changes underneath it
Today's quantum computers are far too noisy to run most algorithms, so the leading near-term approach is the VARIATIONAL QUANTUM ALGORITHM — a hybrid loop where the quantum machine evaluates a candidate circuit, an ordinary classical optimizer compares the results against the previous candidate and adjusts the settings, and the two alternate for hundreds or thousands of iterations. The whole method rests on COMPARING candidates, which silently assumes the machine behaves the same way while those comparisons are made. It does not. Quantum hardware drifts continuously, because microscopic defects in the chip couple to qubits and change how long a qubit can hold its state, and that drift happens over minutes while machines are formally characterized only about once a day. So a brief spell of bad luck can make a genuinely good candidate measure worse than a bad one, and the optimizer, unable to tell, walks confidently in the wrong direction.
-
What people did
Mitigate the machine noise, or make the optimizer more robust
Two families of defence exist. A large body of error-mitigation work characterizes the machine and compensates for its errors — compiling with knowledge of which qubits are good, correcting measurement errors, extrapolating results toward the zero-noise limit, scheduling to avoid crosstalk. Separately, the optimizer itself can be hardened, by only accepting steps that improve the objective, by sampling each gradient more times to average out the noise, or by estimating second derivatives to condition the step.
-
Why it fell short
Mitigation assumes noise holds still, and robust optimizers pay for it in speed
Error mitigation almost universally treats machine noise as STATIC, or at least stable long enough to be measured and compensated. Since full characterization is expensive it happens at coarse intervals — roughly daily on IBM machines — so it cannot see fluctuations that arrive and pass within minutes. The paper measures the damage directly: an 8-qubit circuit with about 50 two-qubit gates averages only 25 percent fidelity with 35 percent variation over 45 hours, and within a single one-hour batch the fidelity varies by nearly 100 percent. On a real 24-hour run, transient spikes leave the result after 500 iterations no better than after 100 — four hundred iterations of scarce machine time wasted. The robust-optimizer route helps somewhat but each technique buys stability by evaluating more per iteration, slowing convergence, and the paper finds two of them actually perform WORSE than the plain baseline on some applications.
-
This paper's idea
Re-run the last circuit as a control, and throw away rounds where drift flipped the verdict
This paper (Chicago and IBM — Ravi, Smith, Baker, Kannan, Earnest, Javadi-Abhari, Hoffmann, Chong) proposes QISMET, and its move is to measure the drift rather than model it. Each round it quietly submits the PREVIOUS round's circuit alongside the current one. That circuit has not changed, so any difference in its result is a direct measurement of how much the machine has drifted in between — a control in the experimental sense. Subtracting that drift gives an estimate of what the current candidate WOULD have scored on a steady machine. Then comes the key judgement: it does not try to correct the number. It only asks whether the drift was large enough to flip the SIGN of the comparison, making a genuinely better candidate look worse or a worse one look better. If the direction still holds, the round is accepted whatever the drift magnitude. If the drift flipped it, the round is discarded and simply re-run, on the reasoning that seriously damaging fluctuations are the exception, so a retry will usually land in calm conditions. This yields 29 to 51 percent better results across six real IBM machines and up to 3 times better in longer simulated runs.
Why this problem is worth solving
Quantum computers are not yet useful for most tasks, and the leading plan for
making them useful in the near term has a structure worth understanding before
anything else.
NISQ stands for NOISY
INTERMEDIATE-SCALE QUANTUM, the current era of machines with roughly 100
imperfect qubits, error-prone enough that they cannot yet beat classical
computers on almost any task. The most promising near-term strategy is the
VARIATIONAL QUANTUM ALGORITHM, a HYBRID method that splits the work between a
quantum machine and an ordinary classical computer. The quantum machine runs a
parameterized circuit — called an ANSATZ — and measures an objective value; a
classical optimizer then compares that value against previous ones, adjusts the
parameters, and sends the circuit back to be run again. The two alternate for
hundreds or thousands of iterations, walking downhill toward a minimum. The
flagship application is estimating the lowest energy state of a molecule, which
is exponentially hard classically but only polynomially hard to PREPARE on a
quantum machine, which is where the potential speedup comes from. The appeal of
this design is that the classical optimizer is expected to absorb some of the
machine’s imperfection by simply tuning around it, which is why variational
algorithms are considered the best candidate for useful work on noisy
hardware
That comparison is exactly where the hidden assumption lives.
TRANSIENT
NOISE is a temporary change in what a quantum circuit outputs, caused by a
sudden shift in the physical characteristics of one or more qubits. Its main
source is a microscopic manufacturing defect called a TWO-LEVEL SYSTEM — an
impurity or crystal irregularity in the chip’s material layers that sits close
enough to a qubit to absorb its energy. What makes this dynamic rather than
static is that the qubit’s own electric fields evolve during operation, so the
strength of that unwanted coupling CHANGES OVER TIME, and with it the length of
time the qubit can hold its state. Measurements over 65 hours show a qubit’s
coherence time varying by around 5 percent most of the time, with occasional
excursions of about 35 percent. Crucially, most fluctuation is harmless — only
the rare severe excursions meaningfully damage a circuit, which means damaging
transients are the EXCEPTION rather than the norm. That fact is what the whole
solution rests on, and it is also why the problem is invisible to conventional
error mitigation, which characterizes a machine roughly once a day and cannot
see something that arrives and passes within minutes
What people did before, and where it broke
- Noise-aware error mitigation. Characterize the machine, then compensate — compile onto the healthiest qubits, correct measurement errors, extrapolate toward zero noise, schedule around crosstalk. Genuinely effective, and the paper positions itself as complementary rather than competing.
- But characterization is expensive, so it is infrequent. Full machine characterization runs roughly once a day, which means every one of these techniques is acting on a snapshot that may be hours stale while the machine fluctuates within minutes.
- Only accepting improving steps. A simple hardening of the optimizer that rejects any update which worsens the objective. It helps against some transients, but it also rejects legitimate exploratory moves, and the paper measures it performing worse than the plain baseline on some applications.
- Sampling each gradient more times. Averaging over repeated measurements reduces random variation, but transient episodes are not random noise around a stable value — they are sustained shifts — and paying double the measurements per iteration slows convergence measurably.
- Estimating second derivatives. Conditioning the step with curvature information is a standard optimizer improvement, but the paper finds it performs consistently WORSE than the baseline in the presence of transients.
- The gap. Every existing approach either assumes the noise holds still long enough to be characterized, or treats the fluctuation as random noise to be averaged away. Nobody had recognised that the damage is specifically about the machine changing BETWEEN the comparisons the optimizer depends on. That is the gap QISMET fills.
How the drift is measured and the bad rounds discarded
Submit a control circuit, estimate the drift, and check whether it flipped the verdict
-
The optimizer compares candidates on a shifting machine
The classical optimizer decides where to move by comparing the current candidate against the previous one, assuming both were measured under the same conditions. Drift breaks that assumption, so a good candidate can score worse than a bad one and the optimizer confidently walks the wrong way.
-
Re-submit the previous round's circuit as a control new
Each batch of work sent to the machine now carries an extra passenger — the exact circuit from the previous iteration, unchanged. Because the circuit is identical, any difference in its result cannot come from the circuit, so it isolates how much the machine itself has moved in between.
-
Turn that difference into a drift estimate new
The gap between the control circuit's new result and its original result is taken as the transient error affecting this round. Subtracting it from the current candidate's measured value gives an estimate of what that candidate would have scored on a steady machine.
-
Compare directions, not magnitudes new
The controller asks only one question — does the measured comparison and the drift-corrected comparison agree on which candidate is better? A large drift that leaves the verdict unchanged is harmless and accepted; a smaller one that flips a better candidate into looking worse is the one that derails tuning.
-
Discard and retry the rounds that flipped new
Rather than correcting the number, the round is thrown away and re-run. Since seriously damaging fluctuations are rare, a retry usually lands in calm conditions. A small cap on repeats prevents getting stuck when a disturbance persists, and swings inside a tolerance band are always accepted so mild noise does not trigger constant skipping.
-
Let the optimizer proceed on trustworthy comparisons new
The optimizer never learns any of this happened; it simply receives comparisons whose direction can be trusted. The goal is not to find the very best candidate but to avoid confidently selecting a genuinely bad one, which is what produces the damaging spikes.
The idea
Measure the confound with a control instead of modelling it. The elegant part of this design is how little it assumes. Predicting how a quantum machine will drift would require a model of physics that nobody has. So QISMET does not predict — it measures, by re-running a circuit it has already run. Because the circuit is unchanged, any difference in outcome can only come from the machine, which turns an unknowable quantity into a direct observation. This is a textbook control condition, and it is the same compare-two-things-that-should-agree logic covered elsewhere on this site in the compiler-differential-testing page, where the same source compiled two ways should produce identical output and any difference is the signal. There the difference exposes a bug; here it exposes drift. The authors are also candid that the reference is imperfect, since the drift affecting the previous circuit is not exactly the drift affecting the current one, but they argue the immediately preceding iteration is the closest available proxy.
Filter by whether the noise changed the DECISION, not by how big it was. The most instructive choice is one the authors explain by ruling out alternatives. The obvious approach is to discard any round whose measured drift exceeds some threshold, and the equally obvious approach is a classical Kalman filter, which uses repeated noisy measurements to estimate the true underlying value. Both were tried and both underperform, for the same reason: they treat all variance as equally bad. But most drift is harmless. What actually damages the optimizer is only drift that FLIPS the comparison — that makes a better candidate look worse. So a large transient that leaves the ranking intact is accepted while a smaller one that inverts it is rejected. Filtering on the quantity that actually changes the outcome, rather than on the quantity that is easiest to measure, is the site’s most persistent lesson, covered elsewhere here in the performance-analysis pages where a convenient proxy quietly misleads, and in the quantum-chiplet page whose authors likewise test and reject the obvious quality metric in favour of one that predicts.
Discard the contaminated sample rather than repairing it. QISMET never corrects a measurement. It detects that a round is untrustworthy and throws it away, relying on the empirical fact that severe transients are rare so a retry will usually succeed. That is far cheaper and far more robust than reconstructing what the answer should have been, and it needs no model of the disturbance. It is also precisely the strategy this group applies to fabrication defects in the companion quantum-chiplet page covered elsewhere on this site, where imperfect chiplets are tested and rejected before assembly rather than compensated for — the same detect-and-discard instinct applied to a static problem there and a time-varying one here. The site sees the same shape wherever a system validates a result before trusting it and simply retries when validation fails.
One round of tuning, with a control circuit attached
Deciding whether to trust a comparison
How QISMET evaluates a single variational iteration. Numbers from the paper's real-machine and simulated experiments.
Step 1 of 5
What the optimizer is about to do
The machine has measured a value for the current candidate and a value for the previous one. Their difference is the gradient, and its SIGN tells the optimizer whether the new parameters are better or worse — which is what determines the direction it moves next.
the optimizer used here needs only two objective measurements per iteration regardless of how many parameters there are nothing in this procedure can distinguish a genuine improvement from a lucky measurement
Why it works
- The optimizer decides direction by comparing candidates, assuming stable conditions → drift between those measurements can invert the comparison → which makes the optimizer confidently select a genuinely worse candidate, the source of the damaging spikes.
- Re-running an unchanged circuit isolates the machine from the algorithm → any difference in its result must come from drift → so an unmodellable quantity becomes a direct measurement with no physics model required.
- Only drift that flips the sign of a comparison misleads the optimizer → so accepting large-but-harmless drift and rejecting small-but-inverting drift targets exactly the damage → which is why magnitude thresholds and Kalman filtering, which treat all variance alike, do worse.
- Severe transients are the exception rather than the norm → so a round thrown away and re-run will usually land in calm conditions → making detect-and-discard cheaper and more robust than attempting to reconstruct the true value.
- The goal is not to pick the best candidate but to avoid picking a bad one → a merely good choice keeps the optimization on track → so a modest amount of skipping recovers most of the loss without needing perfect information.
What it costs (trade-offs and scope)
- It spends scarce quantum machine time on circuits that compute nothing new. Every round carries a repeated reference circuit, and rejected rounds are re-run entirely. On hardware where access is the binding constraint, that overhead is the price of the method.
- The reference is an approximation. The drift affecting the previous iteration is not exactly the drift affecting the current one; the authors state this openly and justify the choice only as the closest available proxy.
- The threshold must be tuned, and both extremes hurt. Set conservatively it skips too little and behaves like the baseline; set aggressively it skips useful rounds and performs WORSE than the baseline when transients are mild. The measured sweet spot rejects about 10 percent of rounds, giving 1.2 times improvement in a low-noise setting and 3 times in a high-noise one.
- A persistent disturbance defeats it. Retrying only helps if the fluctuation passes, so the number of repeats is capped; when a transient lasts, the algorithm must proceed on a compromised measurement anyway.
- The evaluated scale is small and the study is of one algorithm family. Experiments use six-qubit problems on machines of roughly a hundred qubits, limited by what noisy hardware can run, and the longest comparisons come from a simulator driven by recorded traces rather than from hardware.
The evaluation
QISMET was implemented in Python on the Qiskit variational framework and run on seven IBM quantum machines, using six-qubit problems — a physics model chosen partly because it can be solved exactly by classical means, so the true answer is known, plus the potential energy of the hydrogen molecule across bond lengths. Because machine access limits how long a real run can be, the authors additionally recorded transient noise traces from real devices and integrated them into the simulator to run 2000-iteration comparisons. Baselines include plain variational tuning with measurement error mitigation, three hardened optimizers, a magnitude-threshold skipping scheme, and a tuned Kalman filter.
Coping with a quantum machine that drifts during tuning
| Property | Plain variational tuning | Filter or average the noise | Measure drift and discard bad rounds |
|---|---|---|---|
| Assumption about noise | |||
| What it acts on | |||
| Cost per iteration | |||
| Behaviour when noise is mild | |||
| Result |
Check yourself
Check your understanding
1. QISMET needs to know how much the quantum machine has drifted, but nobody can predict that. Predict how it finds out.
2. The authors tried discarding any round whose drift exceeded a threshold, and also tried Kalman filtering. Both underperformed. Predict what QISMET does differently.
3. When a round is rejected, QISMET simply throws it away and runs it again rather than correcting the measurement. Predict why that works.
4. Sweeping the rejection threshold shows that skipping too few rounds AND skipping too many both underperform. Predict why an aggressive setting can be worse than doing nothing.
Sources
- Navigating the Dynamic Noise Landscape of Variational Quantum Algorithms with QISMET (arXiv:2209.12280) — ASPLOS 2023; the full 15-page paper, read in full for this explainer.
- ACM Digital Library (DOI 10.1145/3575693.3575739) — published version.