There are two ways to deal with a quantum computer's mistakes. You can fix them, or you can subtract them after the fact. Fixing them means error correction: bundling many physical qubits into one protected logical qubit, catching faults as they happen, and paying an enormous overhead in extra hardware. That is the long game, and the machines that can play it at scale do not exist yet. So in the meantime, researchers reach for the second option. They let the errors happen, then use clever statistics to estimate what the answer would have been on a perfect machine. This is error mitigation, and it is quietly doing most of the heavy lifting on real quantum hardware right now.
Subtraction, not repair
The distinction matters. Error correction actively protects the quantum state during a computation, so you can run longer and longer circuits without the answer dissolving into garbage. Error mitigation does nothing to the state itself. Instead, it runs a circuit many times, deliberately makes the noise worse in controlled ways, and then works backward to guess the noise-free result. It is a post-processing trick layered on top of noisy runs, not a shield wrapped around the qubits. That makes it cheap in hardware and expensive in run time, which is exactly the trade-off near-term devices can afford.
Two workhorse techniques
The most popular method is zero-noise extrapolation. The idea sounds almost too simple. Take your circuit and run it at its natural noise level. Then run stretched versions that suffer, say, three or five times as much noise, usually by folding gates back on themselves so they cancel mathematically but still accumulate real errors. You now have several data points showing how the answer degrades as noise rises. Fit a curve through them and extend it back to the point of zero noise. The extrapolated value is your best guess at the clean answer. It never actually happened on the machine, but if the trend is smooth, the estimate can be surprisingly good.
The second technique, probabilistic error cancellation, is more surgical and more demanding. It requires a detailed model of exactly how each gate is corrupted. With that model in hand, you can represent the inverse of the noise as a weighted mix of circuits, some of which you run with a plus sign and some with a minus sign. Average them together and the noise formally cancels out. The catch is that this only works if you have characterized the hardware with painful precision, and even then it inflates the number of samples you need dramatically.
The sampling tax comes due
That inflation is the whole problem. Both methods buy accuracy by running the same job far more times than a clean machine would need, and the cost grows steeply with circuit size and error rate. For a modest circuit the penalty is tolerable. For a large one it can balloon into an astronomical number of repetitions, the kind that would tie up a machine for lifetimes. Mitigation does not remove errors so much as trade them for wall-clock time, and there is only so much time to trade.
This is why the field talks about mitigation as a bridge rather than a destination. IBM leaned on zero-noise extrapolation and related methods for its widely discussed 2023 experiment simulating a magnetic material on a 127-qubit processor, arguing the results reached a regime where brute-force classical simulation struggles. Critics quickly showed that clever classical algorithms could match or beat some of those numbers, which sharpened rather than settled the debate. What almost everyone agreed on was the underlying point: mitigation let a noisy chip produce answers that were far better than its raw error rates would suggest.
Living in the gap
Error mitigation exists because of an awkward calendar. The algorithms people want to run demand qubits that behave far better than today's do, and full error correction that would deliver those qubits is still being assembled piece by piece. Mitigation fills the gap in between, extracting a little more signal from imperfect machines while the corrected ones mature.
The two approaches are not really rivals. Future systems will likely correct errors at the logical level and still mitigate whatever leakage sneaks through, because no code is perfect and every last bit of accuracy counts. For now, though, mitigation is the pragmatic answer to a blunt question: what do you do with a quantum computer that makes mistakes on almost every gate? You let it run, run it again, and do the math to pretend it didn't.
