Zero-Noise Extrapolation with Mitiq on Braket

Zero-noise extrapolation with Mitiq on Amazon Braket

In this notebook, we look at extrapolative approaches for mitigating errors, namely zero-noise extrapolation (ZNE) and a variant, layerwise-Richardson extrapolation, using Mitiq with Amazon Braket. Here, Mitiq provides built in functions to (1) execute circuits with ZNE, (2) prepare the extrapolated circuits, and (3) recombine and post-process results.

ZNE provides the backbone mitigation strategy for numerous succussful quantum simulations, and has been incorporated into techniques such as probabilistic error amplification. Numerous references can be found on the Mitiq page.

Installing Mitiq

mitiq is not included by default with amazon-braket-examples requirements or in the Amazon Braket Notebook Instances. To install, uncomment the first line in the next code block, and restart the notebook. Or run install from extra/requirement-mitiq.txt.

Mitiq utilizes Cirq as the backend, and may represent circuits using their representation.

Basics of zero-noise extrapolation

Given a function , we would like to estimate using a series of varying . For ZNE, describes the noise parameter. Importantly, making specific assumptions about noise sources and behavior within our circuit, differing values of correspond with different circuits where we have amplified noise. The most common strategy for noise amplification is unitary gate folding, where we take a gate , and map it to the logically equivalent . This can be the global unitary (global folding), or local unitaries composed together (). Thus, independent noise sources within our system can be amplified by a n odd factor. However, some noise, particularly coherent noise, will remain constant. Correlated noise also can have strange behaviors.

Different extrapolation schemes lead to different biases, and so generally we do not consider ZNE to be an unbiased approach for all noise models. More details can be found on Mitiq`s Theory of ZNE page.

Setting up our problem

In order to set up our ZNE problem, we first import relevant libraries, and construct our system of interest.

Here we see a standard 1-d transverse field Ising model circuit, realized using ZZ Pauli Gadgets. Now we can get ideal expectation values and visualize them.

In this regime we see oscillatory behavior that is pretty consistent across local sites, with the exception of the edges.

Below, we calculate the same result using our noise model.

Running the noise-extrapolated results

Finally, to compare, we will run our ZNE procedure. Note, here the scale_factors represent the noise amplification levels we will perform. We will use the default strategy but Mitiq allows you to explore various folding options for integer and non-integer powers.

Additionally, to look at the extrapolations, we will use the construct_circuits + combine_results pattern, as opposed to the 1-shot Executor based approach seen in the first notebook. We can still use an Executor, as we just need an expectation value, but we will not automate the entire process.

Performing extrapolations with mitiq.zne.inference factories

Now that we have three results, we will look at means of extrapolating these via post processing. In particular, we consider three different fits, a LinearFactory, an ExponentialFactory and a RichardsonFactory.

The LinearFactory performs a simple least-squared fit of the data.

The ExpFactory tries to fit an exponential curve to the data of the form , with . Notably, we can also incorporate the infinite limit, which effectively sets , and then allows for a linear regression of the form . For common expectation value problems, this is typically the trace of the observable .

The RichardsonFactory performs Richardson extrapolation to fit data points to a degree polynomial, of which there is a unique solution. Thus, it has some nice guarantees, namely there are existing expression for the variance and bias of the resulting estimate we can harness.

Taking a closer look at the exponential function performance, we can model it as:

We can further visualize our fits:

On bias and variance in ZNE

For ZNE, there are further factors which can impact the quality of our extrapolation, and lead to increased or modified variances as well as non-zero biases. Below we discuss the three methods covered above.

Variance in linear extrapolation

A linear fit uses a Ordinary Least Squares estimator, which based on a series of points , with variances , produces a linear fit with parameters and . In particular we are interested in the estimator , as this represents the variance of our estimator. From points with similar standard deviations, this can be written as:

We can also compare this with the extrapolated result from Mitiq:

Which is precisely what we would expect. The ordinary least squares approach is unbiased in the sense that the regression model is unbiased, however if the generating function is not linear with normally distributed error variables, then there will be resulting bias. We expect that this can be proportion to the noise strength, and if our scale factors exist in a linear region, then the linear approach might be suitable. It is also appropriate for equal-variance data, i.e. each point is taken with the same number of shots.

Variance in exponential extrapolation

Exponential fits can be trickier. There are several tools for fitting exponentials and higher order polynomials in Mitiq, which can be found in the inference file and documentation. We focus on one variation, which has a nice correlation with the linear fit. Broadly, Mitiq models an exponential function as:

where can be specified as the asymptote, which for traceless observables is 0. If we also use the default avoid_log=False, we can treat this as a function in log space. I.e., we can write this as:

Taking the log of this yields:

.

We can thus identify with and with above. Noting that the variance of our estimate:

this will correspond with a log-normal distribution, assuming that is normally distributed. One problem is that our variances are no longer homoscedastic (i.e. equal variance). Thus we go from using standard linear least squares regression to a weighted least squares regression. In mitiq, a weight least square regression is used with . This can also be supplied as based on the normalization, but in practice the square root may be more stable. From that, we can calculate the weighted-least-squares variance and compare with the mitiq_polyfit function.

To properly normalize the exponential distribution in the log-space, one should have heteroscedastic data in normal space and homoscedastic data in log space, i.e. performing some sort of shot allocation. Unfortunately, the proper alllocation here is hard to know a priori - one proxy might simply be the number of two qubit gates and infidelity. If this is in a linear region, i.e. , then the variances will be transformed appropriately. To properly evaluate this in mitiq we can supply our own weights to mitiq_polyfit and output the relevant extrapolation data.

Variance in Richardson extrapolation

Finally, Richardson extrapolation has the advantage of having exact formulae for the bias and variance of the extrapolation (see Krebsbach et al. for an excellent overview of Richardson extrapolation for QEM). Specifically, based on the Lagrange coefficients, we can estimate our variance. In contrast with linear and exponential extrapolation techniques, Richardson extrapolation also can produce a rigorous bound on the bias. Additionally, Richardson extrapolation gives more insights into noise spacing and allows for flexibility on shot allocation.

For , the Lagrange polynomial of a degree function can be written as:

.

These have a nodal structure, i.e. at each point only will be non-zero, and we can express the extrapolation as

.

The bias can be expressed from the theory of polynomial functions and potentially estimated using known information or approximation information on the function. As mentioned in previous work, to obtain a truly bias-free Richardson extrapolation requires an exponential number of points and thus shots, but in practice we can bound error below reasonable rates quite well.

Regardless, the variance has the formula

Here we see that the variance primarily depends on , with an ideal allocation being

.

Layerwise Richardson extrapolation and variants

For realistic systems, there can be much more complex noise models which affect noise sources. We can address this in a number of ways, particularly by how we change the relation between our extrapolation and circuit.

One such approach supported in Mitiq is layerwise Richarson extrapolation (LRE). If we consider our original extrapolating function with a multivariate input, i.e. , then we can still perform many types of regression. While this is still an open research area, LRE provides an extensive way to perform this extrapolation.

Importantly we use the num_chunks argument to reduce the number of partitions within the circuit, and thus the overall degree of the polynomial.

Summary

In this notebook we looked at extrapolation-nased approaches, including standard zero-noise extrapolation (ZNE) as well as layerwise Richardson extrapolation (LRE). Mitiq has many other options for enhancing ZNE results, which we encourage the interested use to explore.

References

1. Unitary Foundation, Mitiq Guide, ZNE, Accessed 12/9/2025.
2. Temme et al., Error Mitigation for Short-Depth Quantum Circuits (2017), Phy. Rev. Lett., 119, 180509.
3. Majumdar et al., Best practices with ZNE (2023) arXiv:2307.05203.
4. Russo, Mari, Quantum error mitigation by layerwise Richardson extrapolation (2024). Phys. Rev. A, 110, 062420.
5. Krebsbach et al., Optimization of Richardson extrapolation for quantum error mitigation (2022) Phys. Rev. A, 106, 062436.