Zero-Noise Extrapolation for Quantum Circuits

Hello! Welcome to your next lesson on recent advances in quantum computing.

In the previous lesson, we established the high-level principles of Quantum Error Mitigation (QEM) as a pragmatic strategy for near-term devices. We contrasted it with the long-term vision of Quantum Error Correction (QEC) and conceptually introduced Zero-Noise Extrapolation (ZNE) as an intuitive, model-free approach.

Today, we transition from theory to practice. This lesson is designed to guide you through the implementation of ZNE and the analysis of its costs, directly addressing the learning outcome: Implement zero-noise extrapolation (ZNE) for a simple quantum circuit and analyze its sampling overhead.

We will cover the key steps of a ZNE workflow:

1. Noise Scaling: How to digitally and controllably amplify the noise in a quantum circuit.
2. Extrapolation: How to use the noisy results to infer the ideal, zero-noise outcome.
3. Implementation: How to apply these techniques using standard Python libraries like Mitiq and Qiskit.
4. Overhead Analysis: How to quantify the cost of ZNE in terms of the required number of measurements (shots).

1. The ZNE Workflow: Noise Scaling and Extrapolation

The core idea of ZNE is to measure an expectation value $⟨O⟩$ at several known noise levels $\lambda \ge 1$ and then extrapolate the results back to the ideal case where $\lambda =0$. This requires two components: a method to scale the noise and a model for the extrapolation.

As the video explains, the ZNE process involves:

1. Noise Scaling: Since we can't turn down the hardware's intrinsic noise ($\lambda =1$), we instead run modified circuits that effectively amplify it to levels $\lambda >1$. The most common digital technique is unitary folding.

   • Local Folding: Each gate $g$ is replaced by the sequence $g{g}^{†}g$. Since $g^{†}g=I$ in the ideal case, the logic is unchanged, but the number of gates (and thus the accumulated noise) increases. A scale factor of $\lambda =3$ is achieved by replacing every gate with this three-gate sequence.
   • Global Folding: The entire circuit unitary $U$ is replaced by $U(U^{†}U)$. This also results in a scale factor of $\lambda =3$.
   • Partial Folding: To achieve non-integer scale factors (e.g., $\lambda =1.5$), only a fraction of the gates in the circuit are folded. This allows for a finer-grained control over the noise levels.

2. Extrapolation: After obtaining expectation values $\{⟨O{⟩}_{{\lambda }_i}\}$ for a set of noise factors $\{{\lambda }_i\}$, we need to fit a model to extrapolate back to $\lambda =0$. Common choices include:

   • Linear Extrapolation: Assumes $⟨O{⟩}_{\lambda }=a\lambda +b$.
   • Richardson Extrapolation: A specific form of polynomial extrapolation.
   • Exponential Extrapolation: Assumes $⟨O{⟩}_{\lambda }=a{e}^{-b\lambda }+c$, which is often well-motivated by models of incoherent noise leading to exponential decay of the signal.

The choice of folding strategy and extrapolation model is a subtle but critical aspect of applying ZNE effectively.

2. Implementation with Mitiq and Qiskit

Now, let's see how this workflow is implemented in code. We will use Mitiq, a library designed to be a hardware-agnostic layer on top of quantum programming frameworks like Qiskit.

The key abstraction Mitiq uses is the executor. This is a Python function you define that takes a quantum circuit as input, executes it on a backend (a simulator or real hardware), and returns the desired expectation value. Mitiq then uses this function as a black box to perform error mitigation.

Let's walk through the essential code structure demonstrated in the video.

Step 1: Define a Circuit and a Noisy Executor

First, we need a quantum circuit and an executor function that runs it on a noisy simulator.

import qiskit
from qiskit.providers.fake_provider import FakeLima # A noisy simulator
import mitiq

# Assume 'circuit' is a qiskit.QuantumCircuit object
# Assume 'observable' is a qiskit.quantum_info.SparsePauliOp object

# 1. Define the noisy backend
noise_model = qiskit.providers.aer.noise.NoiseModel.from_backend(FakeLima())
backend = qiskit.Aer.get_backend("aer_simulator")

# 2. Define the executor function
def executor(circuit: qiskit.QuantumCircuit) -> float:
    """Executes a circuit on a noisy backend and returns an expectation value."""
    # Transpile the circuit for the backend
    circuit_t = qiskit.transpile(circuit, backend)
    
    # Add measurements
    circuit_t.measure_all()
    
    # Execute and get counts
    result = qiskit.execute(
        circuit_t,
        backend,
        noise_model=noise_model,
        shots=8192,
        optimization_level=0, # Important: prevent compiler from undoing folds
    ).result()
    
    # Calculate expectation value from counts (simplified)
    # In a real scenario, you'd use Qiskit's Estimator primitive
    # or calculate from counts based on the observable.
    counts = result.get_counts()
    # Let's say we measure the probability of the '00' state for a 2-qubit circuit
    exp_val = counts.get("00", 0) / 8192
    
    return exp_val

Step 2: Apply ZNE

With the executor defined, applying ZNE is straightforward. Mitiq handles the noise scaling, execution at different noise levels, and extrapolation behind the scenes.

from mitiq.zne import execute_with_zne

# The original noisy expectation value
noisy_value = executor(circuit)

# The error-mitigated expectation value using default ZNE settings
zne_value = execute_with_zne(circuit, executor)

print(f"Noisy value: {noisy_value}")
print(f"ZNE value:   {zne_value}")

Step 3: Customize the ZNE Workflow

For more control, you can specify the noise scaling and extrapolation methods.

from mitiq.zne.scaling import fold_global
from mitiq.zne.inference import RichardsonFactory

# Define a noise scaling function
# Here, we choose global folding
scaling_f = fold_global

# Define an extrapolation factory with specific scale factors
# Here, we use Richardson extrapolation with scale factors 1, 3, and 5
factory = RichardsonFactory(scale_factors=[1, 3, 5])

# Execute with custom settings
custom_zne_value = execute_with_zne(
    circuit,
    executor,
    scale_noise=scaling_f,
    factory=factory,
)

print(f"Custom ZNE value: {custom_zne_value}")

This modular design allows you to experiment with different ZNE strategies to find what works best for your specific circuit and hardware.

3. Analysis of Sampling Overhead

Error mitigation is not free. While it doesn't require extra qubits like QEC, it imposes a sampling overhead: you need to take significantly more total measurements (shots) to achieve a given statistical precision compared to the unmitigated experiment.

The key takeaways from this section are:

• Source of Overhead: The overhead in ZNE comes from two main sources:

  1. Multiple Executions: You must run the experiment multiple times, at least once for each chosen noise scale factor ${\lambda }_i$. If you use $k$ scale factors, you run $k$ different circuits.
  2. Variance Amplification: The final extrapolated value is a linear combination of the measured expectation values: $⟨O{⟩}_{\text{ZNE}}={\sum }_i{\eta }_i⟨O{⟩}_{{\lambda }_i}$. The variance of this sum is $\text{Var}(⟨O{⟩}_{\text{ZNE}})={\sum }_i{\eta }_i^2\text{Var}(⟨O{⟩}_{{\lambda }_i})$. Since some coefficients ${\eta }_i$ are typically greater than 1, this process amplifies the shot noise from the individual measurements.

• Scaling of Shot Noise: As shown in Figure 5 of the paper, the standard deviation $\sigma$ of the final ZNE estimate due to finite shot noise still follows the expected statistical scaling:

  $${\sigma }_{\text{ZNE}}\propto \frac{1}{\sqrt{N_{\text{shots}}}}$$

  where $N_{\text{shots}}$ is the number of shots used for each noise level. However, the constant of proportionality, $a$, is larger for the ZNE estimate than for a single noisy measurement. This constant depends on the extrapolation coefficients $\{{\eta }_i\}$ and the noise levels of the underlying measurements.

Let's define the total shot budget as $N_{\text{total}}=k\times N_{\text{shots}}$, where $k$ is the number of noise levels. To achieve the same final precision as an unmitigated experiment with $N_0$ shots, a ZNE experiment will require a total shot budget $N_{\text{total}}>N_0$. This ratio $N_{\text{total}}/N_0$ represents the sampling overhead.

Conclusion

In this lesson, you have moved from the concept of ZNE to its practical implementation and analysis. You are now equipped to apply this powerful error mitigation technique to real quantum circuits.

Key Takeaways:

• ZNE is implemented by scaling noise (typically via unitary folding) and extrapolating results (using models like linear, Richardson, or exponential).
• Libraries like Mitiq provide a high-level, hardware-agnostic interface for applying ZNE by wrapping a user-defined executor function.
• Effective ZNE requires careful choices for noise scaling methods, scale factors, and extrapolation models. These choices are often problem-dependent.
• The primary cost of ZNE is sampling overhead. The total number of measurements required increases due to running experiments at multiple noise levels and the amplification of statistical variance during extrapolation.
• The standard deviation of the ZNE estimate scales as $1/\sqrt{N_{\text{shots}}}$, but the prefactor is larger than in an unmitigated experiment.

Preview of the next lesson:
Now that you have hands-on experience with ZNE, we will turn our attention to the other major QEM technique: Probabilistic Error Cancellation (PEC). We will delve into its more complex theoretical foundation, including the quasi-probability decomposition that allows it to provide an unbiased estimate of the ideal result, and rigorously compare its resource requirements and limitations to those of ZNE.