With fault tolerance the ultimate goal, error mitigation is the path that gets quantum computing to usefulness
Quantum error mitigation is the continuous path that will take us from today’s quantum hardware to tomorrow’s faulttolerant quantum computers. This path will let us run larger circuits needed for quantum advantage, one hardware improvement at a time.
Quantum error mitigation is the continuous path that will take us from today’s quantum hardware to tomorrow’s faulttolerant quantum computers. This path will let us run larger circuits needed for quantum advantage, one hardware improvement at a time.
The history of classical computing is one of advances in transistor and chip technology yielding corresponding gains in information processing performance. Although quantum computers have seen tremendous improvements in their scale, quality and speed in recent years, such a gradual evolution seems to be missing from the narrative. Indeed, it is widely accepted that one must first build a large faulttolerant quantum processor before any of the quantum algorithms with proven superpolynomial speedup can be implemented. Building such a processor therefore is the central goal for our development.
However, recent advances in techniques we refer to broadly as quantum error mitigation allow us to lay out a smoother path towards this goal. Along this path, advances in qubit coherence, gate fidelities, and speed immediately translate to measurable advantage in computation, akin to the steady progress historically observed with classical computers.
Of course, the ultimate litmus test for practical quantum computing is to provide an advantage over classical approaches for a useful problem. Such an advantage can take many forms, the most prominent one being a substantial improvement of a quantum algorithm’s runtime over the best classical approaches. For this to be possible, the algorithm should have an efficient representation as quantum circuits, and there should be no classical algorithm that can simulate these quantum circuits efficiently. This can only be achieved for specific kinds of problems.
Accessing a quantum advantage therefore requires us to answer two questions. First, which problems can we map to quantum circuits that have solutions which are better than classical approaches? Second, how can we obtain reliable outcomes for these circuits on quantum hardware with a faster runtime?
Addressing the first question is not something we can do alone. It is our commitment to work with the community and industry experts to find problems that are solvable with quantum circuits that are known to be difficult to simulate classically. This is the reason we have built the world’s largest quantum ecosystem with the IBM Quantum Network, made up of Fortune 500 companies, academic institutions, national entities, startups, and the Qiskit Community to explore the problem space of quantum circuits to drive real application and value.
How then do we chart a path to address the second question in practice?
Current quantum hardware is subject to different sources of noise, the most wellknown being qubit decoherence, individual gate errors, and measurement errors. These errors limit the depth of the quantum circuit that we can implement. However, even for shallow circuits, noise can lead to faulty estimates. Fortunately, quantum error mitigation provides a collection of tools and methods that allow us to evaluate accurate expectation values from noisy, shallow depth quantum circuits, even before the introduction of fault tolerance.
In recent years, we developed^{1} and implemented two generalpurpose error mitigation methods, called zero noise extrapolation (ZNE)^{2} and probabilistic error cancellation (PEC).^{3} The ZNE method cancels subsequent orders of the noise affecting the expectation value of a noisy quantum circuit by extrapolating measurement outcomes at different noise strength. More recently, theoretical and experimental advances have shown that PEC can already enable noisefree estimators of quantum circuits on noisy quantum computers.
In PEC, we learn and effectively invert the noise of the circuit of interest for the computation of expectation values by averaging randomly sampled instances of noisy circuits. The noise inversion, however, leads to prefactors in the measured expectation values that translate into a circuit sampling overhead. This overhead is exponential in the number of qubits n and circuit depth d. The base of this exponential, represented as γ̄, is a property of the experimentally learned noise model and its inversion. We can therefore conveniently express the circuit sampling overhead as a quantum runtime, J:
J = γ̄ ^{nd} β d
Here, γ̄ is a powerful quality metric of quantum processors — in technical terms, γ̄ is a measure of the negativity of the quasiprobability distribution used to represent the inverse of the noise channel. Improvements in qubit coherence, gate fidelity and crosstalk will reflect in lower γ̄ values and consequently reduce the PEC runtime dramatically. Meanwhile, β is a measure of the time per circuit layer operation (see CLOPS),^{4} an important speed metric.
The above expression therefore highlights why the path to quantum advantage will be one driven by improvements in the quality and speed of quantum systems as their scale grows to tackle increasingly complex circuits. In recent years we have pushed the needle on all three fronts:
 We unveiled our 127qubit Eagle processor, pushing the scale of these processors well beyond the boundaries of exact classical simulability.
 We also introduced a metric to quantify the speed of quantum systems — CLOPs — and demonstrated a 120x reduction in the runtime of a molecular simulation.
 The coherence times of our transmon qubits exceeded 1 ms, an incredible milestone for superconducting qubit technology.
 Since then, these improvements have extended to our largest processors, and our 65qubit Hummingbird processors have seen a 23x improvement in coherence, which further enables higher fidelity gates.
 In our latest Falcon r10 processor, IBM Prague, twoqubit gate errors dipped under 0.1%, yet another first for superconducting quantum technology, allowing this processor to demonstrate two steps in Quantum Volume of 256 and 512.
These improvements in the quality of quantum processors have led to continually decreasing γ̄. Measured over the best 10qubit strings on our large processors, here are some examples of the estimated γ̄:
Improvements  γ̄  

Hummingbird r2 (Brooklyn, 65Q)  1.038  
Hummingbird r3 (Ithaca, 65Q)  23x coherence improvements over r2  1.024 
Falcon r10 (Prague, 32Q)  Stateoftheart twoqubit gates, reduced crosstalk  1.012 
Table 1: Comparing the γ̄ of three recent IBM Quantum processors
While these improvements in γ̄ might seem modest, it is important not to underestimate the power of exponentials. The runtime implications of these γ̄ improvements are huge — for instance, for a 100qubit circuit of depth 100, the runtime overhead going from the quality of Hummingbird r2 to Falcon r10 is dramatically reduced by 110 orders of magnitude.
Let’s also look at a concrete example of how reductions in twoqubit gate errors will lead to dramatic improvements in quantum runtime. Consider the example of 100 qubit Trottertype circuits of varying depth representing the evolution of an Ising spin chain. This is at a size well beyond exact classical simulation. In the figure below we estimate the PEC circuit overhead as a function of twoqubit gate error.
As discussed above, twoqubit gate errors on our processors have recently dipped below 1e3. This suggests that if we could further reduce our gate error down to ~ 23e4, we could have access to noisefree observables of 100 qubit, depth 400 circuits in less than a day of runtime. Furthermore, this runtime will be reduced even further as we simultaneously improve the speed of our quantum systems.
We can therefore think of our proposed path to practical quantum computing as a game of exponentials. Despite the exponential cost of PEC, this framework, and the mathematical guarantees on the accuracy of error mitigated expectation values, allow us to lay down a concrete path and a metric (γ̄) to quantify when even noisy processors can achieve computational advantage over classical machines. The metrics γ̄ and β provide numerical criteria for when the runtime of quantum circuits will outperform classical methods that produce accurate expectation values, even before the advent of fault tolerant quantum computation.
To understand this better, let us consider the example of a specific circuit family: hardwareefficient circuits with layers of Clifford entangling gates and arbitrary singlequbit gates. These circuits are extremely relevant for a host of applications ranging from chemistry to machine learning. The table below compares the runtime scaling of PEC with the runtime scaling of the best classical circuit simulation methods, and estimates the γ̄ required for error mitigated quantum computation to be competitive with bestknown classical techniques.
Algorithm  Runtime in seconds (n=d)  Competitive boundary 

Full statevector (Orion)  (5*10^{13})*n^{2} x 2^{n}  γ̄ < 1.01 @ 56 qubits 
Leading classical method^{5}  (1*10^{5})*(1.262)^{n}  γ̄ < 1.003 @ 100 qubits 
Table 2: Competitive boundary at which quantum processors errormitigated with PEC are expected to outperform the corresponding classical algorithm
Improvements in qubit coherence time or better gate fidelities lower the metric γ̄. Faster circuit execution provides a smaller β. These advances then translate into larger circuit volumes that can be run on the noisy hardware while still producing superior expectation values.
Ongoing research into the combination of errormitigation methods with error correction techniques can be interpreted as the lowering of an effective γ̄ for the quantum circuits, as explored for example in Error Mitigation for Universal Gates on Encoded Qubits.^{6} These advances improve γ̄ up until the advent of fully fault tolerant quantum computing. At this point, the exponential scaling turns in to the polynomial overhead ensured by the threshold theorem.
These ideas go beyond just theory; we’ve already started to demonstrate the efficacy of error mitigation on large processors. Building upon recent work,^{3} we consider 50qubit circuits with two layers of CNOT gates (equivalent to an identity operation) and measure Z stabilizers of increasing weight. In the absence of noise, the expectation values are +1, but decoherence, gate errors, and measurement errors heavily bias the accuracy of the observables, particularly with increasing weight. With error mitigation, we are able to show a remarkable improvement in the accuracy of these observables. A particular highlight is the contrast in the highestweight observables before and after error mitigation, serving as a powerful example of trading runtime for extracting noisefree information about the state.
In a second example we go beyond the identityequivalent circuits, and prepare strongly entangled graph states on 36 qubits. Even here, we demonstrate a remarkable recovery in the accuracy of the errormitigated stabilizers, particularly at large weight.
These examples illustrate the power of errormitigation techniques, and show that these techniques continue to work even as the number of qubits increases towards the limit of exact classical simulability.
The ability of PEC to produce noisefree estimators enables clean runtime comparisons with exact classical simulations. We must contrast this with heuristic classical quantum simulation methods that may produce approximations in specific settings. We know of many such heuristics which, in some limit, produce correct expectation values, as is the case for tensor network methods that achieve accuracy in a large bond dimension limit, for example.
Such approximation methods are more suitably compared to error mitigation techniques such as ZNE, which provide biased estimators. The ZNE estimator can provide valuable approximations to the expectation value for low noise rates, and can be progressively improved by increasing the order of the extrapolation. This estimator significantly reduces runtime compared to a full PEC implementation.
The ZNE method was first demonstrated^{7} for studying the ground state energies of small molecules. More recently, we extended the method^{8} to even larger system sizes (up to 26 qubits) and observed that the time evolution of certain error mitigated observables was competitive with respect to approximate tensornetwork based classical methods such as Projected Entangled Pair States (PEPS).
In order to weigh such heuristics against error mitigation methods like ZNE, we can contrast the expense of one resource to one that is relevant to the hardware implementation. For instance, contrast increased computation time for higher bond dimensions to the noise rate of the processor. This places us in the fortuitous situation where we can access computational advantage via certifiably accurate expectation values by employing PEC at the runtime expense discussed here, or by choosing a biased estimator from ZNE with an even lower runtime.
At IBM Quantum, we plan to continue developing our hardware and software with this path in mind. As we improve the scale, quality, and speed of our systems, we expect to see decreases in γ̄ and β resulting in improvements in quantum runtime for circuits of interest.
At the same time, together with our partners and the growing quantum community, we will continue expanding the list of problems that we can map to quantum circuits and develop better ways of comparing quantum circuit approaches to traditional classical methods to determine if a problem can demonstrate quantum advantage. We fully expect that this continuous path that we have outlined will bring us practical quantum computing.
References

Temme, K., Bravyi, S., Gambetta, J. Error Mitigation for ShortDepth Quantum Circuits. Phys. Rev. Lett. 119, 180509 — Published 3 November 2017 ↩

Kandala, A., Temme, K., Córcoles, A.D. et al. Error mitigation extends the computational reach of a noisy quantum processor. Nature 567, 491–495 (2019). ↩

van den Berg, E., Minev, Z., Kandala, A., et al. Probabilistic error cancellation with sparse PauliLindblad models on noisy quantum processors. arXiv. [Submitted on 24 Jan 2022 (v1), last revised 23 Jun 2022 (this version, v2)] ↩ ↩^{2}

Wack, W., Paik, H., JavadiAbhari, A., Jurcevic, P., Faro, I., Gambetta, J., Johnson, B. Quality, Speed, and Scale: three key attributes to measure the performance of nearterm quantum computers. arXiv. [Submitted on 27 Oct 2021 (v1), last revised 28 Oct 2021 (this version, v2)] ↩

Bravyi, S., Gosset, D., Liu, Y. How to Simulate Quantum Measurement without Computing Marginals. Phys. Rev. Lett. 128, 220503 – Published 1 June 2022 ↩

Piveteau, C., Sutter, D. Bravyi, S., et al. Error Mitigation for Universal Gates on Encoded Qubits. Phys. Rev. Lett. 127, 200505 — Published 12 November 2021 ↩

Kandala, A., Temme, K., Córcoles, A.D. et al. Error mitigation extends the computational reach of a noisy quantum processor. Nature 567, 491–495 (2019). ↩

Kim, Y., Wood, C., Yoder, T., et al. Scalable error mitigation for noisy quantum circuits produces competitive expectation values. arXiv. [Submitted on 20 Aug 2021] ↩