⚛️ quantum physics

Hardware-Efficient Error Mitigation and Shot-Efficient Sampling on IBM Quantum Hardware

This paper experimentally evaluates the trade-offs between error mitigation techniques and finite-shot sampling on IBM Quantum hardware under a constrained execution budget, providing a hardware-aware characterization of when mitigation strategies improve estimation accuracy versus when sampling fluctuations negate their benefits.

Original authors: Sumit Chongder (Indian Institute of Technology Jodhpur)

Published 2026-08-31

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Sumit Chongder (Indian Institute of Technology Jodhpur)

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the quiet hum of a server room, a new kind of computer is learning to think. These machines, built from superconducting circuits cooled to temperatures colder than deep space, promise to solve problems that would take today's supercomputers millennia to crack. But there is a catch: these quantum computers are incredibly fragile. The slightest vibration or heat can cause their calculations to go wrong. Because we are not yet able to build machines that are completely immune to these errors, scientists have developed a set of tricks called error mitigation. These tricks do not fix the broken parts of the machine; instead, they try to guess what the correct answer should have been by running the same calculation many times and looking for patterns in the mistakes. The hope is that by combining these noisy results, we can extract a clear signal from the static.

However, there is a hidden cost to these tricks. To get a better guess, the computer must run the calculation more times, using up a limited resource known as "shots," which are simply the number of times the machine is asked to measure its result. If you spend too many shots trying to correct the errors, you might end up with a result that is less accurate than if you had just run the calculation a few times and accepted the noise. This tension between fixing mistakes and running out of attempts is the central puzzle that researchers are trying to solve. They need to know exactly when these correction methods help and when they actually make things worse, especially on the real machines available today.

A researcher at the Indian Institute of Technology Jodhpur decided to test this balance on a real, working quantum computer. They used a powerful 156-qubit processor from IBM, a machine that represents the cutting edge of current technology. Their goal was not just to see if error correction worked, but to measure it fairly by keeping the total number of attempts fixed. Imagine you have a fixed amount of time to take a photograph of a moving object. You can either take one long exposure, which might be blurry, or take many quick snapshots and combine them. The researcher wanted to know if taking many snapshots and combining them with a specific mathematical recipe would actually give a clearer picture than just taking one long shot, given that the total time available was the same for both methods.

The researcher set up a series of experiments using different types of circuits, which are the instructions given to the computer. They tested simple chains of qubits, repeating patterns of operations, and a specific type of calculation used for optimization problems. They compared the raw, uncorrected results against several correction strategies. One strategy involved correcting for errors that happen when the machine reads the final answer. Another involved running the calculation at different levels of artificial noise and then mathematically guessing what the result would be if there were no noise at all. They also tested a smart, adaptive method that tried to decide how many times to run each part of the calculation based on how noisy that specific part seemed to be.

The results were surprising and nuanced. The researcher found that the smart, adaptive method did not automatically win. In fact, when they compared the smart method to a simple, uniform method where every part of the calculation was run the same number of times, the smart method only performed better in two out of six different scenarios. In the other four scenarios, the simple, uniform approach was actually more accurate. This suggests that the complex strategy of constantly adjusting the number of attempts based on preliminary noise checks is not a guaranteed improvement. Sometimes, the extra effort to be "smart" about where to spend the shots actually led to a worse final answer.

Another key finding was that the correction methods did not always fix the bias, or the systematic error, in the way scientists hoped. For one specific type of calculation involving a pattern of up and down states, the method designed to remove noise actually made the error larger than it was before. The researcher observed that when the computer was asked to measure a value that was very close to the edge of what was possible, the mathematical trick used to remove the noise would sometimes overshoot, pushing the answer further away from the truth. This happened even though the method is widely used and trusted. It showed that these tools are not magic wands that work in every situation; they can sometimes introduce new problems while trying to solve old ones.

The study also highlighted the importance of the physical layout of the computer itself. The researcher discovered that simply choosing which wires on the chip to use for their calculation made a huge difference. When they used a pair of wires that were known to be low-error, their results were significantly better than when they used a pair of wires from the same chip that were known to be high-error. The difference in quality between these two pairs of wires was so large that it was comparable to the difference caused by adding several extra layers of complexity to the calculation. This means that before trying to fix errors with software, it might be just as important to carefully select the best physical parts of the machine to run the code on.

Ultimately, the researcher concluded that there is no single, universal rule for when to use error mitigation. The decision depends entirely on the specific machine, the specific calculation being run, and the number of attempts available. On the IBM processor they tested, the adaptive shot-allocation strategy they tested was not superior to the simple, uniform approach. In many cases, the standard error correction methods increased the uncertainty of the result rather than reducing it. The researcher released all their data, code, and the exact instructions they used so that others can repeat the experiments. Their work serves as a reminder that in the noisy world of current quantum computing, the most sophisticated solution is not always the best one, and that careful, honest testing is required before deciding to apply these powerful but costly fixes.

Technical Summary: Shot-Efficient Error Mitigation on IBM Quantum Hardware

Problem Statement
Quantum error mitigation (QEM) techniques, such as Zero-Noise Extrapolation (ZNE) and readout-error correction, are standard tools for improving expectation-value accuracy on Noisy Intermediate-Scale Quantum (NISQ) hardware. However, these methods are not cost-free: they typically reduce systematic bias at the expense of increasing statistical variance. Under a fixed measurement-shot budget, this trade-off creates a "help-harm" boundary where mitigation may fail to improve, or even worsen, the total Mean Squared Error (MSE) compared to raw estimation.

Existing benchmark studies often report accuracy improvements without accounting for the additional sampling cost required to achieve them, making it difficult to determine if mitigation is worthwhile when the shot budget is constrained. Furthermore, while adaptive shot-allocation strategies (e.g., Neyman allocation) have been proposed to optimize variance, their empirical performance on physical hardware under fixed budgets remains under-explored, particularly regarding whether they outperform simple uniform allocation.

Methodology
The author presents a hardware-validated benchmarking protocol that treats the total number of measurement shots as a fixed experimental variable. The study was conducted on a 156-qubit IBM Quantum Heron processor (ibm_marrakesh) using Qiskit Runtime V2 primitives.

Key methodological components include:

Bias-Variance Decomposition: Instead of reporting raw accuracy, the study evaluates mitigation strategies by decomposing the MSE into bias and variance components.
Hardware Characterization: The author utilized a specific calibration snapshot to select a low-error qubit chain and a deliberately high-error coupling edge to study connectivity effects.
Circuit Families: Three circuit types were tested:
- GHZ states (2, 4, 6 qubits) to probe multi-qubit correlation decay.
- Repeated-layer circuits ( $L \in \{1, 2, 4, 8\}$ ) to analyze depth scaling and two-qubit gate counts.
- QAOA MaxCut on a four-node ring graph as an application-relevant benchmark.
Mitigation Strategies Compared:
- M0: Raw estimation.
- M1: Readout-mitigated (confusion matrix correction).
- M2: Uniform ZNE (Unitary folding with noise factors $\lambda \in \{1, 3, 5\}$ and equal shot allocation).
- M3: Adaptive ZNE (ASB-ZNE), which uses a small pilot run (100 shots per factor) to estimate per-factor variance and allocates the remaining budget according to a Neyman-optimal rule ( $N_i \propto |w_i|\hat{\sigma}_i$ ).
- M4: Dynamical decoupling (XY4 sequences) for idle-time error suppression.
Fixed-Budget Comparison: The core experiment compared Uniform ZNE and ASB-ZNE across six matched total shot budgets ( $B \in \{900, \dots, 21000\}$ ), ensuring the total cost ( $N_{shots} \times N_{circuits}$ ) was identical for both arms.

Key Results

Shot-Noise Scaling: Empirical variance on the hardware matched theoretical $1/N$ scaling for moderate to large shot counts, establishing a reliable statistical floor.
Connectivity Effects: The choice of qubit coupler had a magnitude of effect comparable to adding multiple layers of circuit depth. A two-qubit correlator measured on a low-error coupler yielded $\langle ZZ \rangle = 0.909$ , while the same measurement on a high-error coupler (from the same calibration snapshot) dropped to $0.751$.
Mitigation and Bias:
- Readout mitigation provided negligible bias reduction for the tested observables.
- Standard ZNE increased the bias relative to raw measurement for a bias-sensitive parity observable, consistent with known instability in Richardson extrapolation when the true value is near a boundary.
- Dynamical decoupling offered slight improvements at shallow depths but was ineffective or slightly detrimental at deeper circuits where two-qubit gate errors dominated.
Adaptive vs. Uniform Allocation:
- The adaptive ASB-ZNE strategy did not consistently outperform uniform allocation.
- Across six tested budgets, adaptive allocation reduced MSE in only two cases (ratios of 0.998 and 0.988). In the other four cases, it performed worse, with MSE ratios ranging from 1.47 to 5.96.
- The average MSE ratio (Adaptive/Uniform) was 2.16.
- Cause of Failure: The study attributes this to the fact that the error in these circuits was bias-dominated rather than variance-dominated. The Neyman allocation minimizes variance but cannot correct for the bias introduced by the extrapolation model itself. In some cases, the adaptive rule shifted more shots to higher noise factors (larger $\lambda$ ), which carried larger biases, thereby increasing the total MSE.
QAOA Benchmark: For the QAOA MaxCut observable, raw hardware execution overestimated the ideal energy. ZNE measurements at higher noise factors moved further in the same direction, and extrapolation toward $\lambda \to 0$ pointed qualitatively toward the ideal value, though a full fixed-budget comparison for QAOA was not completed due to time constraints.

Significance and Claims
The paper does not claim to propose new extrapolation algorithms or novel adaptive policies. Instead, its contribution lies in providing an experimentally grounded evaluation of existing ideas under a strict, fixed-shot budget on real hardware.

The author concludes that:

Error mitigation and adaptive sampling strategies should not be applied as universal defaults.
The benefit of mitigation is highly conditional on the specific device, circuit family, shot budget, and the nature of the error (bias vs. variance).
On the tested device, a simple pilot-variance-based adaptive allocation for ZNE is often inferior to uniform allocation because it fails to address bias-dominated error regimes.
Hardware-aware qubit and coupler selection can be as effective as, or more cost-effective than, post-hoc error mitigation.

The study advocates for a "fixed-budget, variance-aware" view of error mitigation, urging practitioners to validate whether the expected error reduction exceeds the added sampling cost for their specific use case before deploying mitigation techniques. The full protocol, calibration data, and analysis code are released to support reproduction on other IBM Quantum backends.

Technical Summary: Shot-Efficient Error Mitigation on IBM Quantum Hardware

More like this