A quantum computer at IBM spent about sixteen minutes producing a list of random looking numbers. Generating that same list on a classical computer would take an impractical amount of time, which is the entire point of the exercise. The genuinely new part is that the researchers can also prove how well the machine did it, and until now nobody running one of these experiments could.
The speed is the headline. The proof is the contribution.
Quantum advantage experiments have a catch built into them. You pick a task specifically because classical computers cannot do it. Which means classical computers also cannot check whether the quantum computer did it correctly. Since 2019 the field has papered over this with statistical proxies, numbers that track fidelity if you are willing to assume the hardware noise behaves in particular convenient ways. Those assumptions are not testable in the regime that makes the experiment interesting.
The trick in this paper is to build the hard computation out of an easy one.
Start with a circuit you can check. Measure exactly how faithfully the machine ran it. Then modify that circuit into a hard one, choosing a modification that provably cannot have made things much worse, and quantifying the "much." The fidelity you measured on the easy version, minus a small provable penalty, becomes a floor for the hard version. You never check the hard computation at all. You inherit the check.
Everything below is how they pulled that off, what the numbers actually were, and where the claim is softer than the press release.
The paper is Sampling hard circuits with verifiably high fidelity, posted to arXiv on July 28, 2026 by nine authors from IBM Research and the University of Chicago. The protocol is called doped Clifford sampling. The experiment used 70 data qubits and 27 ancillas, 97 physical qubits in total, on IBM's Boston superconducting processor, running a depth 70 circuit containing 468 T gates. The reported fidelity lower bound is 0.284 at 95 percent confidence.
Build a random brickwork Clifford circuit, equal width and depth. Clifford circuits are classically simulable, which sounds like exactly the wrong place to begin a quantum advantage experiment. It is the right place, because their fidelity can be measured directly and efficiently through direct fidelity estimation. Critically, that measurement makes no assumptions whatsoever about hardware noise.
The authors used 80 randomly chosen stabilizers and 250,000 shots each. A recent result showing that linear depth Clifford circuits can generate an arbitrary stabilizer state on a line means this backbone saturates the available entanglement.
A Clifford circuit carries built in Pauli symmetries. Any Pauli operator that stabilizes the circuit output, with support anywhere in space and time, is a valid parity check. Add ancillas to measure those checks, then keep only the shots where every syndrome comes back clean.
Finding good checks is the hard engineering. The authors used decoder based heuristics to search the Pauli group for low weight, high coverage symmetries. With 27 ancillas they detect 92 percent of all first order errors and approach distance 2 behavior. State fidelity improves by a factor of 29 over the unencoded circuit. The effective sampling rate drops by a factor of 860.
Back propagate each check through the circuit to map its detecting region. Any spacetime location left uncovered by X or Y detection is a place where you can insert a Z rotation without disturbing a single stabilizer. So insert T gates there. 468 of them, the maximum the code permits.
Two things make this work. The doped and undoped circuits detect exactly the same set of faults, so the code's protection survives intact. And on IBM hardware, Z rotations are implemented by virtual frame tracking rather than a physical pulse, so the T gates add no noise at all. The circuit becomes classically intractable and the error budget does not change.
Prior structured proposals inject an amount of magic linear in qubit count. Working in the spacetime picture gets you quadratic, which is why this fits on current hardware and earlier proposals did not.
Measure the fidelity of the undoped Clifford state directly. That comes out to 0.32, uncertainty 0.01. Now dope the circuit. Both the doped and undoped states are projected by the code into the same subspace, and doping only rotates the state within that subspace. So the only way fidelity can fall is if a fault that used to be harmless, meaning one that happened to leave the Clifford state unchanged, becomes harmful once the state has been rotated.
Harmless faults are rare in random Clifford circuits. The authors estimated their contribution by Monte Carlo, sweeping noise strengths and polarizations and classifying every fault configuration by whether the code caught it and whether it stabilized the state. Maximum possible fidelity loss from doping: 0.013, uncertainty 0.001.
Subtract the upper confidence limit on the loss from the lower confidence limit on the measured fidelity. That is 0.284. That is the whole certificate.
The check on the check. The argument collapses if doping quietly changed the noise environment. So they measured the syndrome distributions before and after and found them statistically indistinguishable, which is what you would expect if the T gates really are noiseless.
They also validated the bound in three ways. With only five T gates, direct estimation still works. Doping instead with S gates produces new Clifford circuits whose fidelity can be measured outright. And around 75 T gates, the output distribution has anticoncentrated enough that cross entropy benchmarking becomes a calibrated proxy while Clifford plus T simulators can still perform strong simulation. The bound held in all three.
| 70 data, 27 ancilla | 97 physical qubits on the IBM Boston processor |
| 2,869 CZ gates | 2,415 in the depth 70 computation, 454 for syndrome extraction |
| 468 T gates | The maximum the code structure permits |
| 0.32 (1) | Measured fidelity of the undoped Clifford state, post selected |
| 0.57 (2) | Estimated true fidelity after readout error mitigation |
| 0.013 (1) | Maximum fidelity that doping could possibly have cost |
| 0.284 | Lower bound on the doped state's fidelity, 95 percent confidence |
| 5.90 × 10-4 | Post selection acceptance rate. Roughly 1 shot in 1,700 survives |
| 1.8 × 10-4 | Effective CZ error rate inside the code, a 10x improvement |
| 2,051 samples | Collected in 16.1 minutes of runtime, interleaved across an 8 hour session |
For scale, Google's 2019 Sycamore run reported an XEB fidelity around 0.002 on 53 qubits, and its 2023 follow ups at 67 and 70 qubits reported 0.1 and 0.2 percent. A certified 0.284 is roughly two orders of magnitude above those, and it is a bound rather than a proxy. Those are different kinds of number and the gap between them is the story.
Asymptotically, the authors prove their circuit ensemble is universal in the worst case and show that, granting two complexity theoretic conjectures of the sort every sampling advantage proposal relies on, no efficient classical sampler exists for the average case.
At the actual experimental size the argument is numerical and arrives in two independent pieces. Tensor network contraction scales as roughly 2 to the power of twice the cut width, and an extensive search over balanced cuts found nothing below width 30, which puts that route somewhere north of 10 to the 18th operations. Approximate matrix product state methods normally escape this by truncating a fast decaying Schmidt spectrum, but doped Clifford circuits have a notably flat spectrum, so truncation bleeds fidelity across 70 layers. Stabilizer rank methods hit the complementary wall, since approximating a circuit with t T gates is conjectured to require on the order of 2 to the 0.228t stabilizer terms. At t equals 468 that exponent lands near 107.
They also checked whether confining T gates to code preserving locations accidentally suppressed the magic, which would be an embarrassing shortcut for a classical simulator to find. Stabilizer entropy showed no meaningful reduction against unrestricted doping.
They then say, in as many words, that better classical algorithms may well come. This is the correct posture and a welcome change from the genre.
The bound assumes a general Pauli noise model, which they obtain by twirling, and it assumes the T gates are noiseless because they are virtual Z rotations on this particular architecture. Both assumptions are weaker and more defensible than what cross entropy benchmarking demands. Neither is nothing. The authors are explicit that fully device independent verification, the kind that proves a quantum computer was involved at all without any hardware assumptions, remains open.
Discarding 99.94 percent of your shots is affordable at 97 qubits and will not be at 500. Error detection buys fidelity with sample rate, and the exchange rate worsens as circuits grow. The authors name this as the central scalability problem and point toward error correction rather than detection as the eventual answer.
Syndrome post selection is also not the only filtering in play. Shots flagged for non Markovian errors were discarded separately, gates were Pauli twirled to tailor the noise toward a stochastic channel, and qubits and readouts were calibrated for this specific circuit. All of that is legitimate and disclosed. It is also a reminder that the number at the end sits on top of a substantial amount of curation.
Nothing here is a path to a useful computation. It is a demonstration that a certificate and a hardness guarantee can coexist on hardware that exists today.
A fidelity of 0.284 means the state the machine produced has at least that much overlap with the state the circuit specifies. The majority of the amplitude is still somewhere else. For a sampling demonstration this is fine and the number is excellent by the standards of the field. It is worth keeping straight that a certified 0.284 and a correct answer are different objects.
Every quantum advantage announcement since 2019 has been followed by classical simulation work that narrowed the gap, sometimes dramatically. The tensor network bound here sits around 2 to the 60th, which is large today and not permanently out of reach. The stabilizer rank wall is far more comfortable. The authors flag the exposure themselves and frame the durable contribution as the certificate rather than the speed.
The lay writeups are mostly faithful, and the fifteen minute figure is real. Two things are drifting.
Error detection, not error correction. The distinction is not pedantic. Correction identifies an error and repairs it, and you keep the shot. Detection notices an error and throws the shot away. This experiment discarded roughly 1,700 shots for every one it kept, and the paper states plainly that error detection alone is not scalable indefinitely because of post selection overhead.
Why it mattersCalling this error correction implies the scaling problem has been solved. The paper's own Outlook section says the opposite, and names fault tolerant quantum advantage as future work. The "70 logical qubits" framing has a similar issue, since 70 is the count of data qubits encoded in a spacetime code rather than 70 independently protected logical qubits in the usual sense.
The authors state their primary goal plainly, and it is narrower than the coverage suggests. They set out to show that algorithm agnostic hardness guarantees can coexist with trusted execution of deep, error detected circuits on current hardware. That is a real result. It is not a fault tolerance milestone, and the paper never says it is.
16.1 minutes of total runtime yielding 2,051 post selected samples, with shots interleaved across an 8 hour session so that drifting noise would be distributed evenly. The runtime figure is accurate as reported.
Why it mattersEvery lay account of this paper omits post selection entirely, which is the single most consequential design choice in the experiment. A reader comes away thinking a quantum computer worked for fifteen minutes and produced an answer. What happened is that a quantum computer worked, most of its output was discarded by design, and what survived carries a provable quality floor. The second description is more impressive and harder to fit in a headline.
The headline number is 0.284. The contribution is the word "bound." Every prior sampling demonstration told you how well the machine probably ran, conditional on a noise model you had to accept sight unseen. This one tells you how well it ran at worst, conditional on assumptions it states out loud. That is a smaller claim and a far more useful one.
Anyone who has been handed a model's AUC and asked to trust it will recognize the shape of the problem. Producing an output is one job. Knowing how much of it to believe is a separate job, usually harder, and usually the one that decides whether the thing ever gets used on anything that matters.
Sources
Primary: Martiel S, Chung JU, Seif A, Ghosh S, Hincks I, Deshpande A, Fefferman B, Gambetta JM, Javadi-Abhari A. Sampling hard circuits with verifiably high fidelity. arXiv:2607.25941 [quant-ph], submitted 28 July 2026. CC BY 4.0. arxiv.org/abs/2607.25941
Data: All experimental data and circuits deposited at Zenodo. doi.org/10.5281/zenodo.21633064
Lay coverage: Quantum Computer Solves a Problem in 15 Minutes That Classical Methods Can't Practically Compute. SciTechDaily, August 2026. scitechdaily.com
Comparison, 2019: Arute F et al. Quantum supremacy using a programmable superconducting processor. Nature 574:505-510, 2019. Reported XEB fidelity approximately 0.002 on 53 qubits. nature.com
Comparison, 2023: Google's 67 qubit and 70 qubit random circuit sampling runs reported estimated XEB fidelities of 0.1 and 0.2 percent respectively.