Zero-Noise Extrapolation (ZNE) Mitigation

• The paper presents a digital methodology using unitary folding and parameter noise scaling to amplify noise and extrapolate error-free expectation values, achieving suppression factors up to 24×.
• It details a robust approach where various extrapolation models, including linear, exponential, and adaptive schemes, are employed to optimize fidelity in quantum computations on real hardware.
• The study highlights trade-offs such as increased circuit depth and statistical uncertainty, emphasizing the need for adaptive protocols to balance error mitigation with resource overhead.

Zero-noise extrapolation (ZNE) is an error mitigation strategy for quantum computation that estimates ideal, noise-free expectation values of observables by intentionally amplifying, or “scaling,” the noise in a quantum circuit and then extrapolating measured outcomes to the zero-noise limit. Critically, ZNE achieves this with no additional quantum resources and is independent of specific noise models, thus providing a hardware-agnostic path to improved quantum computation in the absence of full-scale quantum error correction (Giurgica-Tiron et al., 2020).

1. Foundational Principles of Zero-Noise Extrapolation

ZNE principle: for a quantum circuit $U$, one defines a noise scaling parameter $\lambda$ such that $\lambda = 1$ corresponds to the device’s native noise level and $\lambda = 0$ represents a theoretically noiseless case. The quantum circuit is executed at several $\lambda \geq 1$, producing a set of noisy expectation values $E(\lambda)$ for an observable of interest. ZNE proceeds in two steps:

1. Noise Scaling: Run the quantum circuit at $m$ discrete noise levels $\{ \lambda_1, \lambda_2, ..., \lambda_m \}$.
2. Extrapolation: Use the tuple $(\lambda_j, E(\lambda_j))$ to infer $E(0)$.

The underlying assumption is that the functional dependence $E(\lambda)$ is smooth (e.g., at least locally analytic) in $\lambda$, enabling polynomial, exponential, or mixed-model extrapolations. This approach is most justified when noise is incoherent and the noise channels commute with the circuit unitaries; in practice, sufficiently accurate results have been demonstrated even with realistic hardware noise models (Giurgica-Tiron et al., 2020).

2. Digital Noise Scaling: Unitary Folding and Parameter Noise Scaling

2.1 Unitary Folding

The central digital approach to noise scaling is unitary folding:

• For a unitary $U$, the circuit is replaced by

$U \rightarrow U (U^\dagger U)^n$

Here, $(U^\dagger U)^n$ is the identity ideally, but on real hardware each gate incurs noise, increasing the effective error rate without changing logical function.

Circuit vs Gate (Layer) Folding

• Circuit Folding: Entire circuit folded as above; circuit depth increases by a factor $(2n + 1)$.
• Gate/Layer Folding: Each gate $L_j$ is folded individually:

$$L_j \rightarrow L_j (L_j^\dagger L_j)^{n} \qquad \text{or} \qquad L_j \rightarrow L_j (L_j^\dagger L_j)^{n+1}$$

for selected index sets $S$. Provides finer control over the noise amplification.

In the presence of depolarizing noise with $p$ parameter per gate, unitary folding leads to an effective scaling $p \rightarrow p^\lambda$ and expectation values modeled by exponential ansatz:

$$E(\lambda) = a + b p^{\lambda} \qquad (a, b \text{ constants}).$$

Advantages: No hardware-level pulse specialization is required; compatible with the native instruction set of most platforms. Limitations: Systematic coherent errors may not be amplified as folding can result in error cancellation.

2.2 Parameter Noise Scaling

Parameter noise scaling addresses calibration (pulse-area) errors:

• For $G(\theta) = \exp(-i \sum_j \theta_j H_j)$, actual implementation has $\theta_j' = \theta_j + \hat{\epsilon}_j$ (Gaussian noise $\sim \mathcal{N}(0, \sigma_j^2)$).
• To scale noise by $\lambda$, set $$\theta_j' = \theta_j + \sqrt{\lambda} \hat{\epsilon}_j$$.

For rotation-like $H$ with $H^2=I$, such additive angle errors induce decoherence characterized by $Q = [1 - \exp(-2\sigma^2)]/2$, resulting in an effective channel that can be directly scaled.

In summary, these methods allow digital, programmable, and device-compatible noise scaling for ZNE error mitigation (Giurgica-Tiron et al., 2020).

3. Extrapolation Schemes and Adaptive Statistical Inference

3.1 Extrapolation Models

Various functional forms $E_\text{model}(\lambda; \Gamma)$ are fitted to the dataset $\{ (\lambda_j, y_j) \}$:

Extrapolation Model	Formulation
Linear (degree 1)	$E(\lambda) = c_0 + c_1\lambda$
Polynomial (degree $d$)	$$E(\lambda) = c_0 + c_1\lambda + \ldots + c_d\lambda^d$$
Richardson	$$E(0) = \sum_{k=1}^m y_k \prod_{i \neq k} (\lambda_i/(\lambda_i - \lambda_k))$$
Exponential	$E(\lambda) = a + b\exp(-c\lambda)$
Poly-exponential	$$E(\lambda) = a \pm \exp(z_0 + z_1\lambda + \ldots + z_d\lambda^d)$$

• Polynomial (Richardson) Extrapolation: Provides unbiased estimates in the infinite-shot limit but has variance that grows exponentially in $m$ due to shot noise amplification.
• Exponential/Poly-exponential: Appropriate when expectation values decay exponentially with noise scale (e.g., depolarizing noise).

3.2 Adaptive Extrapolation

An adaptive protocol updates both optimal noise scale factors $\lambda_k$ and shot allocation based on Bayesian inference from previous data. For the exponential model ($E(\lambda) = a + b \exp(-c\lambda)$) with known $a$, measurement allocation is optimized via mean squared error formulas for $b$ and $c$, with the next scale factor chosen to minimize estimation error. The optimal relative positioning is determined by the solution to $$e^{c(\lambda_2 - 1)} (c(\lambda_2 - 1) - 1) - 1 = 0$$ (yielding an optimal $c(\lambda_2 - 1)\approx 1.27846$).

Adaptive extrapolation leads to improved error suppression, especially when measurement budgets are fixed or scale factors can be optimized dynamically (Giurgica-Tiron et al., 2020).

4. Performance, Scaling, and Trade-off Considerations

4.1 Empirical Benchmarking

Comprehensive numerical and experimental benchmarks demonstrate the effectiveness of ZNE:

• Randomized benchmarking circuits (2-qubit): Error suppression factors of 18–24$\times$ relative to unmitigated circuits when using quadratic or exponential extrapolation.
• 6-qubit random circuits: Output fidelity, as measured by $L_2$ distance from ideal, improved by factors up to 7$\times$ with gate folding and quadratic extrapolation.
• Variational Quantum Algorithms (QAOA/MAXCUT): Error-mitigated results are percent closer to the classical optimum.
• Real hardware (IBMQ London, 5 qubits): Linear/exponential extrapolation methods yield noticeably enhanced expectation values. Instability in Richardson extrapolation is observed for large $m$ (high-variance), whereas exponential and adaptive methods remain robust.

4.2 Computational Overhead and Limitations

• Circuit depth increases as a function of folding factor; for circuit folding, effective depth $d(2n + 1) + 2s$ for $n$ folds.
• Statistical uncertainty grows with the extrapolation order for models like Richardson, making practical implementation challenging at high noise scales.
• ZNE does not eliminate errors originating from shot noise or systematic coherent errors that may not scale predictably with folding.

Exclusive reliance on digital noise amplification is less robust when noise deviates from the Markovian, time-invariant regime or when coherent components are significant (Giurgica-Tiron et al., 2020).

5. Practical Implementation and Programming Guidance

5.1 ZNE Workflow

1. Transpile (compile) the target circuit to the hardware’s native gate set.
2. Apply digital noise scaling (unitary folding, gate folding, or parameter noise scaling) to produce noise-amplified versions.
3. Execute all circuits at each noise scaling $\lambda_j$ and collect measurements for the target observable.
4. Select an extrapolation method (linear, polynomial, exponential, Richardson, or adaptive) appropriate to the circuit, noise, and available measurement budget.
5. Fit the model to all $(\lambda_j, E(\lambda_j))$ points and report the extrapolated $E(0)$ as the mitigated estimate.

5.2 Extrapolation and Resource Considerations

• For shallow or moderately noisy circuits, low-order polynomial or exponential extrapolation suffices.
• For more aggressive mitigation, Richardson extrapolation with $m$-point polynomial interpolation becomes more variance-limited unless shot overhead is increased proportionally.
• Adaptive protocols dynamically refine noise scale choices and shot allocation, optimizing accuracy for a fixed measurement budget.

5.3 Integration with Variational Algorithms and NISQ Workflows

ZNE readily integrates with variational quantum algorithms (e.g., VQE, QAOA), randomized benchmarking, quantum simulation circuits, and hardware platforms supporting standard quantum instruction sets, and is increasingly supported in quantum software frameworks. It is particularly advantageous for NISQ-era calculations where circuit depths are modest and quantum resources are limited (Giurgica-Tiron et al., 2020).

6. Limitations, Extensions, and Outlook

The digital ZNE approach fundamentally relies on the experimentalist’s ability to scale noise without introducing significant non-idealities in its spectral profile. Deviations from Markovianity or time-invariance, unaddressed coherent errors, and inaccuracies in hardware execution can limit the achievable fidelity in error mitigation. Complementary strategies such as randomized compiling to convert coherent errors to effective stochastic noise, or hybrid error correction/error mitigation, can enhance ZNE’s effectiveness.

A crucial challenge is the trade-off between mitigation strength (via high extrapolation order or large $\lambda$) and statistical uncertainty, especially under deep circuit execution or limited measurement budgets. The adaptive statistical inference protocol addresses this by optimizing measurement allocation and noise scaling dynamically for each experiment instance (Giurgica-Tiron et al., 2020).

In conclusion, digital zero-noise extrapolation, incorporating unitary and parameter noise scaling with flexible, statistically robust extrapolation methods, provides a powerful, software-compatible error mitigation tool for near-term quantum computing, supported by both theoretical analysis and empirical benchmarks on simulated and hardware platforms.