Erasing errors at 1,000 spots needs 537 million times more runs

What happened

Record a friend talking in a loud market. Play it back and you hear hiss. One fix is to record the same sentence many times and average the takes. The hiss cancels out, and the voice survives.

Quantum computers work in much the same way, because every step leaks a small error. So you run the same program many times and do maths on the pile of answers to guess what a perfect machine would have said. That is called error mitigation, and it is why today’s quantum machines give any usable answer at all.

A new review gathers these tricks in one place. It also puts a price on them. The price is the number of runs you must pay for, and it grows very fast.

The test

There is no test, because this is a review. The paper is called “Practical Error Suppression and Mitigation for Reliable Quantum Computing”. Han-Ze Li, Mengjie Yang, Xianquan Yan and colleagues wrote it. They are at the National University of Singapore, the Singapore Institute of Technology, and Shanghai University in China. It is dated 24 August 2026 and sits on arXiv as a preprint. No journal or conference is named.

The paper does two things. It sorts the many ways of fighting errors into layers. Some stop errors getting in, and some clean up afterwards. Some encode the information so errors can be spotted and undone.

Then it does the arithmetic on cost. One table works out how many extra runs one popular method needs, for a simple model of noise. That table is the part worth staring at.

The result

Take a machine where each spot in the circuit goes wrong half a percent of the time. Clean up 100 such spots and you need about 7.46 times as many runs. Clean up 500 spots and the factor is about 23,200. Clean up 1,000 spots and it is about 537 million.

The error rate never changed, and only the number of spots did. The cost explodes because it multiplies at every one. Doubling the error rate to one percent at 100 spots takes the factor from 7.46 to 56.9.

The review also records what the field has really managed. One cleanup method has run on a circuit of 26 qubits, 120 layers deep, with about 1,080 two-qubit gates. It was later pushed onto a 127-qubit machine with 2,880 two-qubit operations. A Google surface code memory used 101 physical qubits and reached a logical error of about 0.143 percent per correction cycle. Atom-based work has run up to 48 logical qubits on up to 280 atoms.

What it means

Here is the point to hold on to. ERROR CLEANUP IS NOT FREE, AND ITS PRICE IS MACHINE TIME. Cloud quantum time is sold by the second. Therefore a method that needs a million times more runs is a method you cannot afford, however clever the maths.

This changes how you read a demo. A headline that says a quantum computer got the right answer is only half the story. The other half is how many runs it took, and whether that number can grow with the problem.

The review makes a second useful point. The old split between noisy machines now and perfect machines later is not real. This is because machines are arriving in the middle, and they correct some errors and still leak others. Therefore the cleanup tricks are being rewritten to work on top of error correction, not instead of it.

Business ideas from this paper

1. A shot budget calculator. It is a small web tool where you type in your circuit size and your error rate, and it tells you the runs needed and the likely cloud bill before you spend anything. Who buys it: quantum software teams and research groups working through paid cloud credits. A price to test: 20 dollars a month for saved projects and team sharing. A one-week test: publish the free calculator, put only saving behind a sign-up, and count the sign-ups.
2. A quantum credit audit. You look at one team’s month of cloud quantum spending and report where the runs went and which cleanup settings wasted them. Who buys it: research and development groups at banks, drug firms and chemical firms that already bought quantum cloud time. A price to test: 1,200 dollars per audit. A one-week test: do two free, publish the anonymised savings, then ask a third team to pay.
3. A hands-on course in error mitigation software. The review names several toolkits and provider runtimes that do this work. Teach people to use them on a real cloud machine in one day. Who buys it: physics and computing graduates, and engineers moving into quantum jobs. A price to test: 350 dollars per seat, online. A one-week test: run one free session, then see how many of those people pay for the second.

How sure can you be?

Start with what this paper is. It is a review, and it reports no new experiment. The results it quotes belong to other groups. Treat it as a well-organised map, not as new evidence.

The 537 million figure needs care too. It comes from a simple model where the only error is a bit flipping, worked out from a formula in the paper. However, real hardware noise is messier. The authors present the table to show the shape of the growth, not to price any particular machine.

The review is candid about limits. It says the accuracy and the cost of these methods stay limited by physical error rates, circuit depth, mismatch between the noise model and the real noise, drifting calibration and sampling overhead. It says these methods extend the reach of noisy hardware without turning it into a fault-tolerant machine.

No journal or conference is named, and no code or data comes with it. What would settle the question is a mitigated quantum run that beats the best ordinary computer on a job somebody pays for, with the full run count published beside the answer.

Do this today

The next time you read a quantum result, look for one missing number. Ask how many times the program was run to get it. If nobody will tell you, you have your answer.

Source: Practical Error Suppression and Mitigation for Reliable Quantum Computing, August 2026. arXiv:2608.20453 · arxiv.org (preprint · not yet peer reviewed).

Just Out Tech explains new research in plain language. This article was drafted with AI assistance and checked by a human against the original source.