# How do I use ZNE?#

ZNE is an easy to use technique which can be used in a single step
(for those who are in a hurry), or two steps (for those who want more control over the process). Both steps characterizing ZNE — noise scaling and extrapolation — can be easily applied with Mitiq. The
corresponding sub-modules are
`mitiq.zne.scaling`

and
`mitiq.zne.inference`

.

As with all techniques, ZNE is compatible with any frontend supported by Mitiq:

```
import mitiq
mitiq.SUPPORTED_PROGRAM_TYPES.keys()
```

```
['braket', 'cirq', 'pennylane', 'pyquil', 'qibo', 'qiskit']
```

In the next cell you can select the frontend used in this tutorial. For example:

```
frontend = "cirq"
```

## Problem setup#

We first define the circuit of interest. For simplicity, in this example we use a randomized-benchmarking circuit whose ideal execution is equivalent to the identity operation.

```
from mitiq import benchmarks
circuit = benchmarks.generate_rb_circuits(
n_qubits=1, num_cliffords=2, return_type = frontend,
)[0]
print(circuit)
```

```
0: ───Y───X^0.5───Y^0.5───X^0.5───Y^0.5───(Z^0.5-X^0.5)───
```

As an example, below we define a simple executor function which inputs a circuit, executes it on a noisy simulator, and returns the probability of the ground state. See the Executors section for more information on how to define more advanced executors.

```
import numpy as np
from cirq import DensityMatrixSimulator, depolarize
from mitiq.interface import convert_to_mitiq
def execute(circuit, noise_level=0.01):
"""Returns Tr[ρ |0⟩⟨0|] where ρ is the state prepared by the circuit
executed with depolarizing noise.
"""
# Replace with code based on your frontend and backend.
mitiq_circuit, _ = convert_to_mitiq(circuit)
noisy_circuit = mitiq_circuit.with_noise(depolarize(p=noise_level))
rho = DensityMatrixSimulator().simulate(noisy_circuit).final_density_matrix
return rho[0, 0].real
```

The executor can be used to evaluate noisy (unmitigated) expectation values.

```
# Compute the expectation value of the |0><0| observable.
noisy_value = execute(circuit)
ideal_value = execute(circuit, noise_level=0.0)
print(f"Error without mitigation: {abs(ideal_value - noisy_value) :.5f}")
```

```
Error without mitigation: 0.03869
```

## Apply ZNE#

Zero-noise extrapolation can be easily implemented with the function
`mitiq.zne.zne.execute_with_zne()`

.

```
from mitiq import zne
mitigated_result = zne.execute_with_zne(circuit, execute)
```

```
print(f"Error with mitigation (ZNE): {abs(ideal_value - mitigated_result):.{3}}")
```

```
Error with mitigation (ZNE): 0.000231
```

Here we observe that the application of ZNE reduces the estimation error when compared
to the unmitigated result.
In the example above, both the noise *scaling* and *inference* steps were taken behinds the scenes thanks to
the default options of `execute_with_zne()`

where the default noise scaling method is `fold_gates_at_random()`

and the executor computes the average expectation value once. Below we provide more details about these two aspects of ZNE
in Mitiq.

## Select a noise scaling method#

In Mitiq, one can select a noise scaling method via *noise scaling functions*.
A noise scaling function takes a circuit and a real scale factor as two inputs and
returns a new circuit. The returned circuit is equivalent to the input one (if executed on a noiseless backend),
but is more sensitive to noise when executed on a real noisy backend. In practice, by applying a noise
scaling function before the execution of a circuit, one can indirectly scale up the effect of noise. The noise scaling
function can either increase the total circuit execution time by inserting unitaries or increase the wait times in the
middle of a circuit execution. These two methods are *unitary folding* and *identity scaling* respectively.
See the section What additional options are available in ZNE? for more details.

For example, the default function `fold_gates_at_random()`

applies the *unitary folding* map \(G \rightarrow G G^\dagger G\)
to a random subset of gates of the input circuit.
The folded circuit is more sensitive to gate errors since it has a number of gates approximately
equal to `scale_factor * n`

, where `n`

is the number of gates in the input circuit.

```
from mitiq.zne.scaling import fold_gates_at_random
folded = fold_gates_at_random(circuit, scale_factor=2.)
print("Folded circuit:", folded, sep="\n")
```

```
Folded circuit:
0: ───Y───X^0.5───X^-0.5───X^0.5───Y^0.5───X^0.5───Y^0.5───Y^-0.5───Y^0.5───(Z^0.5-X^0.5)───(X^-0.5-Z^-0.5)───(Z^0.5-X^0.5)───
```

## Select a noise extrapolation method#

Define a `Factory`

object to select the noise extrapolation method and the noise scale
factors. The section
What additional options are available when using ZNE? also
contains more details on the available noise extrapolation methods in Mitiq.

For example, a linear extrapolation method with scale factors 1 and 2, can be initialized as follows:

```
from mitiq.zne.inference import LinearFactory
linear_fac = LinearFactory(scale_factors=[1.0, 2.0])
```

We can use the defined Factory and chosen noise scaling method to apply ZNE.

```
from mitiq import zne
mitigated_result = zne.execute_with_zne(
circuit, execute, factory=linear_fac, scale_noise=fold_gates_at_random,
)
```

```
print(f"Error with mitigation (ZNE): {abs(ideal_value - mitigated_result):.{3}}")
```

```
Error with mitigation (ZNE): 0.00299
```

The section What additional options are available when using ZNE? contains more information on both noise scaling and noise extrapolation methods in Mitiq.