⚛️ quantum physics

A Useful Metric for the NISQ Era: Qubit Error Probability and Its Role in Zero Noise Extrapolation

This paper introduces the qubit error probability (QEP) as a comprehensive, pre-execution device metric and demonstrates that using it to guide zero noise extrapolation significantly suppresses observable errors in large-scale NISQ simulations on IBM Quantum Heron processors, offering a resource-efficient path to reliability without full quantum error correction.

Original authors: Nahual Sobrino, Unai Aseginolaza, Joaquim Jornet-Somoza, Juan Borge

Published 2026-02-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Nahual Sobrino, Unai Aseginolaza, Joaquim Jornet-Somoza, Juan Borge

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

Imagine you are trying to bake a perfect cake, but your oven is broken. It fluctuates in temperature, sometimes too hot, sometimes too cold, and the timer is unreliable. You want to know what the cake would have tasted like if the oven were perfect, but you can't fix the oven right now.

This is the current state of Quantum Computing. We have powerful new "ovens" (quantum computers) that can solve problems classical computers can't, but they are incredibly "noisy." The tiny particles they use (qubits) are fragile, lose their state easily, and make mistakes during calculations. We are in an era called NISQ (Noisy Intermediate-Scale Quantum), where we have to work with these imperfect machines.

Here is a simple breakdown of the paper's solution, using our baking analogy.

1. The Problem: Counting "Mistakes" the Wrong Way

Traditionally, when scientists tried to fix errors in quantum computers, they used a method called Zero-Noise Extrapolation (ZNE).

Think of ZNE like this: You bake the cake once. Then, you bake it again, but you deliberately turn the oven up to 100% hotter. Then you bake it a third time at 200% hotter. You taste all three cakes, see how the flavor gets worse as the heat gets higher, and then you draw a line back to guess what the cake would taste like at "zero heat" (perfect conditions).

The Flaw: The old way of doing this was like saying, "I added one extra layer of cake, so the error is exactly double." It assumed errors grew in a simple, straight line. But in reality, quantum errors are messy. Sometimes adding a little more "heat" (noise) causes the whole cake to collapse, not just get a little burnt. The old method was too simplistic and didn't account for which part of the cake was burning.

2. The New Tool: The "Qubit Error Probability" (QEP)

The authors of this paper introduced a new metric called QEP (Qubit Error Probability).

Instead of just guessing the total error, QEP is like a personalized health report for every single ingredient in your cake.

It checks: How old is this egg? (Relaxation/Decay)
It checks: Is the whisk mixing too roughly? (Gate Errors)
It checks: Is the thermometer reading wrong? (Measurement Errors)
It checks: Is the heat from the oven affecting the neighbor's pan? (Crosstalk)

The QEP calculates the specific probability that each individual qubit will mess up the calculation. It combines all these tiny risks into a single, accurate number for the whole circuit. It's like knowing exactly how likely your oven is to fail at every single minute of baking.

3. The Solution: Smarter Extrapolation

Now, they use this new "Health Report" (QEP) to improve the ZNE method.

How they do it:
Instead of just blindly making the circuit "bigger" (which is the old way), they add specific, harmless "dummy" moves to the quantum circuit. Imagine adding a few extra, unnecessary stirring motions to your batter.

These extra moves don't change the final recipe (the answer), but they do make the oven work harder.
Because they know exactly how much "stress" these extra moves put on the machine, they can calculate the exact QEP for that specific run.

They run the experiment three times:

Original: Low stress, low QEP.
Medium Stress: Added dummy moves, medium QEP.
High Stress: More dummy moves, high QEP.

Because they know the exact QEP for each run (not just a guess), they can draw a much more accurate line back to "Zero Error."

4. The Results: A Better Cake

The team tested this on IBM's latest quantum computers (Heron processors) using a complex physics simulation (the Ising model, which is like simulating how magnets interact).

The Old Way (Standard ZNE): When the circuits got too big, the old method got confused. It couldn't tell the difference between "a little noise" and "a lot of noise" accurately, so the final guess was still wrong.
The New Way (QEP-ZNE): By tracking the specific error probability of each qubit, they could predict the "perfect" result much more accurately, even when the machine was very noisy.

Why This Matters

This is a big deal because:

No Magic Required: We don't need to wait for perfect, error-free quantum computers (which might take decades). We can get better results today with the broken machines we have.
Efficiency: It doesn't require massive amounts of extra computing power. It just requires a smarter way of measuring the noise.
Transparency: It gives scientists a clear window into where the errors are happening, rather than just guessing.

In Summary:
The authors realized that the old way of guessing how bad quantum computers were was like guessing a car's speed by looking at the speedometer without knowing if the needle was stuck. They built a new dashboard (QEP) that measures the engine, the tires, and the fuel separately. By using this detailed dashboard to guide their "noise correction," they can now drive the quantum car much closer to the destination, even on a bumpy road.

1. Problem Statement

In the Noisy Intermediate-Scale Quantum (NISQ) era, quantum computers suffer from inherent noise (decoherence, gate errors, measurement errors, and crosstalk) that limits the accuracy of computations. While Zero-Noise Extrapolation (ZNE) is a leading error mitigation technique, it faces a critical limitation: how to accurately quantify and control noise amplification.

Current Limitations: Standard ZNE implementations (e.g., in Qiskit) typically rely on simplistic metrics, such as assuming error scales linearly with circuit depth or the number of gate repetitions. This approximation is flawed because error accumulation in quantum circuits is non-linear and depends on specific hardware characteristics (qubit stability, gate fidelity, connectivity).
The Gap: There is a need for a device-specific, pre-execution metric that accurately reflects the actual error probability of a circuit without requiring classical simulation of the full quantum state (which becomes intractable for large qubit counts).

2. Methodology

A. The Qubit Error Probability (QEP) Metric

The authors propose Qubit Error Probability (QEP) as a new figure of merit. Unlike total error probability, QEP calculates the probability of no error occurring on an individual qubit, combining all error sources into a single value per qubit.

Components of QEP: The metric aggregates four primary error sources:
1. Relaxation ( $T_1$ ) and Dephasing ( $T_2$ ): Modeled via exponential decay based on the total time a qubit is active in the circuit ( $t_j$ ) and hardware calibration times ( $\tau_{i,j}$ ).
2. Gate Errors: Probabilities derived from single and two-qubit gate fidelities provided by the hardware API.
3. Measurement Errors: Readout error probabilities.
4. Crosstalk: While generally negligible on the tested hardware (IBM Heron), the framework accounts for it.
Calculation Logic:
- Success probability for qubit $j$ ( $S_j$ ) is the product of success probabilities for all operations affecting it.
- $QEP_j = 1 - S_j$ .
- The Mean QEP ( $\mu$ ) across all qubits is used as the scalar variable for extrapolation.
Tooling: The authors utilize TED-qc (Tool for Error Description in Quantum Circuits), an open-source pre-processing tool that parses circuit topology, maps logical to physical qubits, and extracts calibration data from the IBM API to compute QEP before execution.

B. QEP-Guided Zero Noise Extrapolation

The authors integrate QEP into the ZNE workflow to replace standard noise scaling factors with a physically meaningful metric.

Noise Amplification Strategy: Instead of arbitrary gate repetition, the method inserts pairs of controlled native two-qubit gates (specifically Controlled-Z or CZ gates on IBM Heron) onto all connected qubit pairs.
- Since a pair of identical unitary gates is the identity operation, the logical expectation value remains unchanged.
- However, the physical execution time and gate count increase, thereby increasing the Mean QEP.
Extrapolation Process:
1. Execute the original circuit (Factor 0).
2. Execute circuits with 1, 2, and 3 pairs of added CZ gates (Factors 1, 2, 3), generating a sequence of increasing Mean QEP values.
3. Measure the observable (e.g., magnetization) for each.
4. Perform a linear regression of the observable against the Mean QEP.
5. Extrapolate to QEP = 0 to estimate the noise-free result.
Complementary Techniques: The method is combined with T-REX (for measurement error mitigation) and Twirling to ensure that the extrapolation focuses primarily on gate and coherence errors.

3. Key Contributions

Definition of QEP: Introduction of a hardware-aware, per-qubit error metric that combines relaxation, dephasing, gate, and measurement errors into a single computable value.
Refined ZNE Protocol: A novel ZNE implementation where the "noise level" is defined by the calculated Mean QEP rather than arbitrary circuit depth scaling.
Pre-Execution Estimation: The ability to predict error probabilities and optimize mitigation strategies before running the quantum circuit, using only calibration data.
Scalability: The method is demonstrated on circuits with up to 68 qubits and 15 Trotter steps, a scale where classical simulation of error dynamics is impossible.

4. Results

The study was benchmarked on the IBM Quantum Heron (ibm_torino) processor using the Transverse Field Ising Model (2D) as a test case.

Clifford Point Validation:
- Simulations were run at a Clifford point ( $J=\pi, h=0$ ) where the exact analytical solution is known.
- Performance: The QEP-guided ZNE significantly outperformed standard ZNE for circuits with 6–16 Trotter steps.
- Error Reduction: In regimes where the raw circuit had a finite Mean QEP, the QEP method suppressed observable errors beyond the limits of depth-scaled ZNE.
Non-Clifford Regime:
- Tests were conducted with varying transverse fields ( $h$ ) on 32 qubits (simulatable classically for verification).
- The QEP method consistently provided results closer to the theoretical exact values compared to standard ZNE and raw (unmitigated) circuits.
Optimal Factors: The study found that using a combination of the raw circuit and amplification factors 1, 2, and 3 yielded the best linear extrapolation results.
Resource Efficiency: The method required only three additional noise-scaled evaluations (plus the raw run) and no heavy classical post-processing, maintaining the low overhead characteristic of ZNE.

5. Significance

Practical Reliability: The paper demonstrates a practical route to improving reliability on current superconducting hardware without the massive resource overhead of full Quantum Error Correction (QEC).
Hardware Awareness: By leveraging specific hardware calibration data (via QEP), the method adapts to the specific noise profile of the device, making it more robust than generic depth-scaling approaches.
Transparency: QEP provides a transparent, interpretable metric for error, allowing researchers to understand why a circuit is failing (e.g., is it gate errors or decoherence time?) rather than treating noise as a black box.
Future Impact: This approach bridges the gap between noisy hardware and useful quantum advantage, offering a scalable, tunable, and efficient error mitigation strategy applicable to a wide range of quantum algorithms and platforms.