Article Title]Echo-evolution data generation for quantum error mitigation via neural networks

1]Danila<EMAIL_ADDRESS>
[1]Dukhov Research Institute of Automatics (VNIIA), Moscow, 127055, Russia

Neural networks provide a prospective tool for error mitigation in quantum simulation of physical systems.

However, we need both noisy and noise-free data to train neural networks to mitigate errors in quantum computing results.

Here, we propose a physics-motivated method to generate training data for quantum error mitigation via neural networks, which does not require classical simulation and target circuit simplification.

In particular, we propose to use the echo evolution of a quantum system to collect noisy and noise-free data for training a neural network.
Under this method, the initial state evolves forward and backward in time, returning to the initial state at the end of evolution. When run on the noisy quantum processor, the resulting state will be influenced by with quantum noise accumulated during evolution. Having a vector of observable values of the initial (noise-free) state and the resulting (noisy) state allows us to compose training data for a neural network. We demonstrate that a feed-forward fully connected neural network trained on echo-evolution-generated data can correct results of forward-in-time evolution.

Our findings can enhance the application of neural networks to error mitigation in quantum computing.

§ INTRODUCTION

Development of quantum computers in recent years led to demonstrating genuinely nontrivial results [1, 2] on devices with up to hundreds of qubits and non-ideal components[3].
Despite this, fault-tolerant quantum computing with error-correcting codes is still beyond nowadays technological level.
Until fault-tolerant quantum computing unfolds, there is an alternative solution - to support NISQ devices with quantum error mitigation (QEM)[4]. Quantum error mitigation is an approach to reduce the effect of quantum noise in the results of quantum computing via additional data sampling and post-processing.
Up to date, several examples of QEM have been demonstrated  [5, 6, 7] and theoretical understanding of QEM has advanced [8] to make QEM a convenient tool to support further development of quantum computing.

A data-driven approach to quantum error mitigation [9, 10, 11, 12, 13] is a branch of QEM, which is a promising enhancement to the existing QEM toolbox.
The data-driven approach to QEM includes gathering noisy and noisy-free data and fitting (training) an ansatz function to approximate a mapping between noisy and noisy-free data. The trained ansatz function is then used to post-process data from a noisy quantum device. To date, there are several works related to data-driven QEM.
In [9], the idea to use Clifford gates to generate classical data to provide ideal observables of a target circuit, is proposed.
The data is then used to train a linear anzatz function to error mitigation.
This method was demonstrated to be used with other QEM techniques to provide good error mitigation performance [11].
Another group of works demonstrates the use of non-linear anzatz functions - neural networks - in quantum error mitigation. There was demonstrated the capability to correct dynamics of many-body observables, corrupted with quantum gate errors [12], and the capability to mitigate measurement errors [13].

Training neural networks requires gathering data set, which consist of corresponding noisy and noise-free observable values. For a problem of quantum dynamics simulation, our final target is a quantum state of the system at model time $t$. To have noise-free observable data on such a state requires us to simulate the dynamics classically - a generally infeasible task for systems in the regime of quantum advantage ($>$ 50 qubits). Thus, there is a need for a workaround method to generate noise-free data for quantum error mitigation.
A possible solution to this problem was proposed in [12]. There, lower-depth versions of quantum circuits are used to generate data output of target (deep-depth) circuits. As the circuit in [12] is a Trotter decomposition of the evolution operator, the depth of the circuit is controlled by a number of Trotter steps.
Although being a working solution, this approach bounds the opportunity to simulate quantum dynamics for long times as a lower Trotter approximation leads to lower quantum simulation accuracy.

In this paper, we propose a physics-motivated method to generate data for quantum error mitigation via neural networks, which does not require classical simulation and target circuit simplification.
In particular, we demonstrate that the echo evolution - an evolution of a quantum system forward and backward in time - allows the production of noisy and noise-free data required to train a neural network.
We show that a neural network trained on such data can mitigate the effect of quantum noise on the results of forward-in-time evolution, which is the actual target of quantum simulation.
To illustrate the proposed method, we simulate dynamics of a 2D spin system under the transverse-field Ising Hamiltonian. We show that, for realistic gate noise, the neural network, trained on echo-evolution-generated data, mitigates effect of gate noise in forward-in-time dynamics results.

This paper is organized as follows.

We provide background on the transverse-field Ising model in Sec.<ref>.

We formulate a method of data generation via echo-evolution in Sec.<ref>.

We provide results on QEM via a feed-forward neural network, trained on data from echo evolution of a 6-spin system, in Sec.<ref>.

We provide analysis of the hidden layer width of our neural network in Sec.<ref>, where we show that the quality of error mitigation saturates for a number of neurons in the hidden layer, approximately equal to size of data vectors.

We draw a conclusion in Sec.<ref>

§ DYNAMICS OF THE TRANSVERSE FIELD ISING MODEL

One of the main problems, which has an advantage of using quantum computing, is the simulation of quantum system dynamics. As was initially proposed by Feynmann [14] and Manin [15], quantum computing allows working with the whole basis of the Hilbert space of the quantum system, which is exponential in the number of particles in the system. Among others, simulating the dynamics of quantum spin systems is one of the most important parts of quantum computing many-body physics [16]. The main model of spin many-body physics is the transverse-field Ising model [17]. This model allows investigating various many-body phenomena [16, 18, 19].
A hamiltonian of the transverse field Ising model is

\begin{equation}
\label{Ising_hamiltonian}
H = -h\sum_{i=1}^{N}\sigma^{X}_{i} - J\sum_{ij}^{N}\sigma^{Z}_{i}\sigma^{Z}_{j}
\end{equation}

where $h > 0$ is on-site energy of a single spin and $J > 0$ is interaction energy between coupled spins, and $\sigma^{Z}_{i}$, $\sigma^{X}_{i}$ are Pauli matrices with eigenvalues $\pm 1$. The quantum spin system undergoes evolution under this hamiltonian from an initial state $\ket{\psi(0)}$ at time $t=0$ to a final state $\ket{\psi(t)}$ at arbitrary time $t$, and the two states are connected as

\begin{equation}
\ket{\psi(t)} = e^{-iHt}\ket{\psi(0)}
\end{equation}

where $e^{-iHt}$ is an evolution operator. The dynamics of this spin system is straightforward to run on a quantum computer: every single spin maps on a single qubit, and the evolution operator consists of single- and two-qubit gates available on the hardware. A convenient way of constructing the evolution operator from quantum gates is via Trotter decomposition. For a hamiltonian with two non-commuting parts $H_{A}$ and $H_{B}$ ($[H_{A}, H_{B}] \neq 0$) the Trotter decomposition for $N$ steps is

\begin{equation}
\label{Trotter}
e^{it(H_{A} + H_{B})} \approx (e^{i\frac{t}{N}H_{A}}e^{i\frac{t}{N}H_{B}})^{N}
\end{equation}

with an error of the size $O(\frac{t^{2}}{N})$. There are Trotter decompositions of the higher order [20], which provide lower decomposition error and allow simulating dynamics for longer times.

After evolving the initial state $\ket{\psi(0)}$ to the final state $\ket{\psi(t)}$, we usually measure a quantum observable $\mathcal{\hat{O}}$, which corresponds to a physical quantity in the modeled system. For the $N$-qubit system, the observable can be of the following form

\begin{equation}
\label{observable_gen}
\mathcal{\hat{O}} = \hat{O}_{1} \otimes \hat{O}_{2} \otimes \dots \otimes \hat{O}_{N}
\end{equation}

where $O_{j}$ is a single-qubit observable. In quantum computing, we usually have hardware-implemented access to measurements on a computational basis, which allows measuring operators of the form

\begin{equation}
\mathcal{\hat{O}}_{i} = \ket{i_{1}}\bra{i_{1}} \otimes \ket{i_{2}}\bra{i_{2}} \otimes \dots \otimes \ket{i_{N}}\bra{i_{N}}
\end{equation}

for $i = 0, 1, ..., 2^{N}-1$ and binary representation $i = i_{1}i_{2}...i_{N}$. To measure arbitrary observable $\mathcal{\hat{O}}$ we need to rotate a basis with a rotation $U$ such that $U^{\dagger}\mathcal{\hat{O}}U$ has a computational eigenbasis. For example, with two qubits, an observable $Z\otimes Z$ is measured in computational basis because $Z = \ket{0}\bra{0} - \ket{1}\bra{1}$, but an observable $X\otimes X$ needs state rotation with Hadamard operators, because $H X H = Z$.

§ DATA GENERATION VIA ECHO EVOLUTION

To use neural networks for quantum error mitigation, we need to collect data with noise-free observable values ($Y_{data}$). Generally, we want to use a quantum processor to run problems that are beyond the reach of classical computing. Thus, for noisy data from a NISQ device ($X_{data}$), we usually cannot simulate noise-free data ($Y_{data}$).

There are possible solutions throughout the literature. For quantum measurement error mitigation, small depth circuits with single-qubit rotations allow constructing states with classically-predictable counts statistic [21, 13]. For the QAOA problem, using Clifford-gate circuits demonstrated successful error mitigation for ground state energy of a spin system [9]. Finally, using data from forward-in-time dynamics with fewer deep circuits allowed mitigating errors in observable dynamics in deep circuits in a problem of quantum simulation of spin system dynamics [12].

This work concentrates on the last mentioned problem - simulation of quantum dynamics. In [12], the data generation procedure produces training data using shallow-depth circuits of the target system evolution. As a quasi-ideal data, a Trotter decomposition with $N_{1}$ Trotter steps, with $N_{1}$ small enough to make the gate error effect negligible. Then, noisy data is generated by choosing a target number of Trotter steps $N_{2}$ and adding “delay” circuits to make quasi-ideal circuits of depth $N_{1}$ to make the noise effect high enough for the depth level $N_{2}$. This procedure generates a training data set of noisy observables $X_{data}$ and noise-free observables $Y_{data}$ to train a feed-forward neural network to mitigate the noise effect.

The main drawback of the described method is a restriction on the quasi-ideal circuits depth. A limited number of Trotter steps is allowed to make the data produced with quasi-ideal circuits approximately noise-free. This limitation restricts generating observable data only for small-time dynamics since the accuracy of simulated dynamics depends on the accuracy of Trotter decomposition (<ref>): the fewer Trotter steps are, the less accurate the resulting dynamics.

A solution comes from physical insights of quantum systems evolution science. In general, given an initial state $\ket{\psi_{init}}$, it is only possible to find the value of observable $O$ on the final state $\ket{\psi_{final}}$ (after evolution) via running the system evolution

\begin{equation}
\ket{\psi_{final}} = e^{-iHt}\ket{\psi_{init}}
\end{equation}

and then measuring an observable of interest

\begin{equation}
\mathcal{O}(t) = \bra{\psi_{final}}\mathcal{\hat{O}}\ket{\psi_{final}}.
\end{equation}

However, there is a specific kind of evolution where knowing the initial state is enough to know the answer after evolution - the echo evolution (Fig. 1(a)). The echo evolution is the following:

\begin{equation}
\ket{\psi_{final}} = e^{iH\frac{t}{2}}e^{-iH\frac{t}{2}}\ket{\psi_{init}} = \ket{\psi_{init}}
\end{equation}

The resulting observable value is then

\begin{equation}
\label{Orelation}
\mathcal{O}(t) = \bra{\psi_{final}}\mathcal{\hat{O}}\ket{\psi_{final}} = \bra{\psi_{init}}\mathcal{\hat{O}}\ket{\psi_{init}} =
\mathcal{O}(0).
\end{equation}

The relation (<ref>) states that given an initial quantum state $\ket{\psi_{init}}$, the observable value after a unitary echo evolution is known beforehand. However, when we run the echo evolution on a noisy quantum device, the observable value after the evolution will be influenced by with the overall quantum noise on a quantum device. In other words, we know a desirable outcome from a quantum device and the error-corrupted outcome from running the echo-evolution.

The schematic description of the echo evolution and forward-in-time evolution. During echo evolution, a system evolves forward and backward during overall time $t$. In case of no noise during evolution, the system will return to the initial state. During the forward-in-time evolution, the system evolves during overall time $t$ to some final state.

Data generation scheme.
We prepare $K$ random initial states $\ket{\psi_{j}}, j = 1,\dots,K$. We measure the observable $\mathcal{\hat{O}}$ on each initial state to produce noise-free data. Then, every initial state is prepared again and is subject to echo-evolution under the transverse-field Ising hamiltonian (<ref>).

During the evolution, the system is subject to quantum noise, which we depict with a red star in the middle of each circuit line.

After evolution, the system ends in a state $\rho_{j}$, on which we measure the observable $\mathcal{\hat{O}}$ and obtain error-corrupted values.

The main goal of quantum error mitigation in the simulation of quantum dynamics is to mitigate noise influence on observables from forward-in-time dynamics (Fig. 1(b)). The data generation method provided here uses the same evolution operator of the quantum system, which produces the target (forward-in-time) evolution. If the depth of circuits, which generate echo and forward-in-time evolutions, is the same, then these evolutions are subject to the same level of noise. Thus, a neural network trained on an echo-evolution-generated data set can correct the effect of noise on the forward-in-time evolution outcome. As we demonstrate in the following section, this is indeed the case.

§ RESULTS

§.§ Quantum error mitigation in forward-in-time evolution

Here, we use a neural network, trained on an echo dynamical data set, to correct forward-in-time evolution results under the transverse field Ising hamiltonian (<ref>). The test data set consists of $100$ vectors for different initial states (see Appendix <ref> for simulation details). For every initial state, we simulated noisy dynamics for $20$ time points in the range $[0, \pi]$ (in $h$ units) and calculated the evolution of single spin magnetizations and average magnetization over the spin system. We provide an example of the corrected evolution of magnetization with a trained neural network (for both single spins and average magnetization) in Fig. <ref>.
To characterize correction efficiency over different initial states of a spin system, we introduce a correction efficiency value $K$. If $K = 1$, the correction corresponds to a perfect correction, $K = 0$ corresponds to no correction, and $K < 0)$ corresponds to a decrease of results quality after neural network post-processing (see Appendix <ref> for details).
In Fig. <ref>, we provide correction efficiency value $K$ for forward dynamics of 100 initial random states. These $K$ values for every state are averaged over all 20 time points to produce a single value.

We can see that a neural network trained on echo evolution can correct forward-in-time evolution results.
Thus, a neural network trained to mitigate the quantum noise effect on echo evolution can mitigate the quantum noise effect in forward-in-time evolution.
The quality of correction for average magnetization dynamics is predictably better than for single spin magnetization (see $K$ values for average (left) and single spin (right) dynamics in Fig. <ref>).
From Fig. <ref>, we see that most of the states from a 100-state sample have a positive correction efficiency value $K$.

Finally, in Fig. <ref>, we provide examples of single spin magnetization dynamics before and after neural network correction. We again see that a neural network can mitigate the effect of quantum gate noise on the quality of observable dynamics of the forward-in-time evolution.

An interesting point is that the proportion of data with positive error mitigation ($K > 0$) is approximately $88\%$. The same proportion of corrected states is observed in echo-evolution data (see Appendix <ref>). This proportion can be improved with doing more shots for every quantum circuit.
It is unclear how this proportion depends on the noise level of quantum gates. Experiments with another level of noise (done by authors during this work) do not allow corroboration of any hypothesis.

Left: forward-in-time evolution of average chain magnetization of a random initial state with noise-free evolution (blue), noisy evolution (red), corrected with neural network (green), and exact evolution (black).
Right: Forward-in-time evolution of magnetization of individual spins for the initial state, described on the left plot.

Values of correction efficiency $K$ for forward-in-time evolution of 100 random initial states. States are sorted with respect to the correction efficiency value $K$.

Forward-in-time evolution of individual spin magnetizations for 4 random initial states.

§.§ Analysis of the neural network size

In this section, we demonstrate that for the dynamics we here consider the number of neurons in the hidden layer can be equal to approximately the size of data vectors.
For that purpose, we train ensembles of neural networks with different widths of their hidden layers on different subsets of echo-evolution-generated data. Then, we calculate correction efficiency (<ref>) and statistics of changes in magnetization data vectors before and after postprocessing with a trained neural network (<ref>). We keep all other hyperparameters fixed (see Appendix <ref> for details).

In Fig. <ref>, we provide dependence of the correction efficiency value (<ref>) on the width of the hidden layer for different levels of quantum noise (values of two-qubit gates error $q_{2}$).
From Fig. <ref>, we see that the correction efficiency (<ref>) for noisy data stops increasing after approximately 8-neurons width of the hidden layer - even for 200 neurons in the hidden layer, we have almost the same performance of error mitigation as we have with an 8-neuron layer.
We provide additional details on statistics of average magnetization differences in Appendix <ref>.

This result is surprising since making neural networks larger generally leads to better results. We see that a relatively small width of the hidden layer was enough for almost the best quantum error mitigation performance.
Here, we investigated a single setup - the dynamics of a spin system with a fixed size, implemented with only a particular kind of single- and two-qubit gate noise (depolarizing). It is interesting to investigate other types of quantum noise and more systems with different quantum observables.

Values of correction efficiency (<ref>) for neural networks with different widths of the hidden layer. Average values and standard deviation were calculated over results from 50 realizations of neural networks with fixed hidden layer width. Results provided for data with different levels of noise (indicated with different values of two-qubit gate noise $q_{2}$).

§ CONCLUSION

We introduced a physics-motivated method to generate data for training neural networks for quantum error mitigation. This method uses the echo evolution of a quantum system to generate noisy and noise-free data vectors.
This method does not require classical simulation and simplification of target evolution circuit and thus is practically applicable to problems of the quantum advantage size($\geq 50$ qubits).
We demonstrated that a neural network trained on echo-evolution-generated data mitigates effect of quantum noise on results of the forward-in-time evolution.
For illustration, we used a system of 6 spins, evolving under the transverse-field Ising Hamiltonian, whose evolution we implemented via noisy quantum gates.
As a side result, we observed that the width of the single hidden layer of our network only requires about ten neurons to give almost the best possible performance of quantum error mitigation.

There are several ways to improve the proposed method. The method uses random initial states to generate data set with echo evolution. In this form, the method intrinsically uses the fact that the depth of circuits used to prepare initial states is much more shallow than evolution-generating circuits. Although it is practically reasonable, it goes with a certain amount of noise, which affects the noise-free part of the data. The first possible solution is reducing the noise by limiting the initial states to states generated with depth-restricted circuits. For example, we can use only one layer of single-qubit rotations to generate initial states. As provided in [22, 13], one layer of single-qubit rotations allows the generation of almost noise-free states with exactly known form and, thus, with known observable values. The second possible solution is to use even simpler initial states - computational basis states of the form $\ket{00...0}, \ket{100...0}, ..., \ket{111...1}$ - with a set of different hamiltonians of the same type $H_{1}, H_{2}, ..., H_{K}$. For example, $H_{j}$ is a hamiltonian of the form (<ref>) with different parameters $h = h_{j}$ and $J = J_{j}$. This last approach gives a minimal number of single-qubit gates to prepare initial states.

The method we provide here can stimulate applications of neural networks for quantum error mitigation.
Data-driven QEM provides a prospective tool to enhance the capabilities of NISQ devices.
In general, all data-driven methods learn a mapping between noisy and noise-free observable data.
Recent results provide reasoning that, for large quantum circuits, this mapping could be of almost rescaling form [23, 24], as the cumulative quantum noise acts almost as white noise [25].
So, in essence, data-driven methods provide a clever way of learning how to rescale (with a slight nonlinearity) observable values affected by quantum noise.
We have already seen that neural networks can mitigate quantum evolution noise [12] (gate noise and decoherence during evolution) and
quantum measurement noise [22, 13].
Still, there is a vast machinery of neural network science that could give even better results in NISQ computing. For instance, it is unknown what capabilities of more advanced architectures (e.g., denoising autoencoders, generative adversarial networks [26]) are in the task of quantum error mitigation.

As neural networks enter the field of quantum error mitigation, an important question is to compare neural networks to other methods [4]. In particular, the scaling of neural network size and efficiency concerning various experiment variables (e.g., data dimension, training sample size, noise level, or neural network width/depth) is unknown. Other QEM techniques (e.g., Zero Noise Extrapolation and Probabilistic Error Cancellation [5], Virtual Distillation [7]) have known efficiency under a general framework [8].
As we demonstrated, a neural network with a single hidden layer can saturate its quality with a small hidden layer width. It is possible that the number of neurons needed to mitigate quantum noise effect depends on the complexity of the system dynamics. The spin dynamics considered in this work required a number of neurons, which is equal to approximately the size of the system.
Further experiments with systems of different sizes and types of quantum noise and theoretical scaling analysis are interesting subjects for future research.

§ ACKNOWLEDGEMENTS

The author would like to thank W.V. Pogosov for careful reading the manuscript and providing feedback. Simulation were made using qiskit library [27]. Illustrations for quantum circuits were made using quantikz library [28].

§ SUPERVISED LEARNING OF FEED-FORWARD FULLY-CONNECTED NEURAL NETWORKS

Neural networks are compound functions which can approximate a data-underlying function. Recently, neural networks were used as an effective instrument for solving problems in physics [29]. Eventually, the use of neural networks spread to quantum informatics [30, 31, 32] and to quantum error mitigation [21, 22, 12, 2]. It is a reasonable advancement of applications since the error mitigation aims to post-process data from a noisy quantum device with an approximately inverse noise map, which can be a function that the neural network approximates. Here, we provide some notions of neural network machinery we will need in the following.

The most straightforward approach to training neural networks is supervised learning. To formulate this approach, we need to recall a notion of the data set. Suppose we have vectors $\vec{x}$ and corresponding “labels” $\textbf{y}$.
A set of these pairs $\{\vec{x}_{i}, \textbf{y}_{i}\}|_{i=1}^{N}$ belongs to a population of all vectors $\vec{x}$ and $\textbf{y}$ and have an underlying functional dependency $\mathcal{F}(\vec{x}) = \textbf{y}$. The set $\{\vec{x}_{i}, \textbf{y}_{i}\}|_{i=1}^{N}$ is called a data set. Depending on structure of $\textbf{y}$, the data set can induce a classification problem ($\textbf{y} \in [1, 2, ...]$), regression problem ($\textbf{y} \in \mathbb{R}$), or be another kind of mapping problem ($\textbf{y} = \vec{y}$).

The aim of supervised learning is to train a parameterized function $f(\vec{x}, \hat{W})$ - for example, a neural network - to approximate the function $\mathcal{F}$ on the whole domain of values, using only available data set $\{\vec{x}_{i}, \textbf{y}_{i}\}|_{i=1}^{N}$. Such a neural network must have many parameters and enough non-linearity to be expressive to learn a data function $\mathcal{F}$ from provided data. The most simple architecture of a neural network is a fully connected neural network. Every layer of such a network does a nonlinear map of the form

\begin{equation}
x_{out}^{j} = \sigma
\biggl(
\sum_{i=1}^{N}W_{ji}x_{in}^{i} + b_{j}
\biggl),
\hspace{0.25cm}
\vec{x}_{out} = (x_{out}^{1}, x_{out}^{2}, ..., x_{out}^{N^{'}}).
\end{equation}

Here, $W_{ji}$ and $b_{j}$ are neural network parameters to be trained, and $\sigma(.)$ is a non-linear function, $x_{in}^{i}$ and $x_{out}^{j}$ are vector components of input and output vectors.
Several such layers compose a neural network. For example, a neural network with an input layer, a single hidden layer, and an output layer has the following form:

\begin{equation}
\label{neuralnet_func}
f(\vec{x}, \hat{W}, \hat{b})
\sigma_{2}
\biggl(
\sum_{j_{2}=1}^{N_{2}}W_{j_{2}j_{1}}
\sigma_{1}
\biggl(
\sum_{j_{2}=1}^{N_{1}}W_{j_{1}i}x_{in}^{i} + b_{j_{1}}
\biggl)
+ b_{j_{2}}
\biggl).
\end{equation}

Here we denoted all trainable weights on different layers as $\hat{W}$ and all trainable biases as $\hat{b}$, $\sigma_{1(2)}$ - non-linear functions, applied after hidden (output) layer correspondingly.
For our purposes, the understanding of neural networks as functions of the form (<ref>), which takes vectors $\vec{x}_{in}$ as inputs and returns vectors $\vec{x}_{out} = f(\vec{x}_{in}, \hat{W}, \hat{b})$ as outputs, is sufficient.

Having data set $\{\vec{x}_{i}, \textbf{y}_{i}\}|_{i=1}^{N}$ and a neural network $f(\vec{x}, \hat{W}, \hat{b})$, the goal is to train a neural network to approximate functional dependence of data set such that the network can realize this dependence on unseen data vectors $\vec{x}$. The training usually requires two ingredients - choosing a loss function and a training optimization procedure. The loss function $L(f(\vec{x}, \hat{W}, \hat{b}), y)$ measures the error between the network output and a correct value of $\textbf{y}$. Calculating loss values over the data set, we construct an empirical risk

\begin{eqnarray}
\label{empirical_risk}
R(\hat{W}, \hat{b}) = \frac{1}{N} \sum_{i=1}^{N}L(f(\vec{x}_{i}, \hat{W}, \hat{b}), \vec{y}_{i})
\end{eqnarray}

which we minimize over iterations of training. The training process is a gradient descent towards the minimum of empirical risk (<ref>), with the use of back-propagation of error through weights in different layers [33]. Usually, the training process continues until a satisfactory local minimum of the function (<ref>) is reached and a set of neural network parameters is known

\begin{equation}
(\hat{W}_{*}, \hat{b}_{*}) = arg \min_{W, b} R(\hat{W}, \hat{b})
\end{equation}

§ SIMULATION DETAILS

§.§ Spin system evolution

To demonstrate the idea, we simulate the evolution of a 6-spin system under the transverse-field Ising hamiltonian (<ref>). We choose parameters $h=1$ and $J = h/2$ and set the system a ladder topology (see Fig. <ref>). We mapped every spin to a single qubit. We implemented the unitary evolution operator $e^{-iHt}$ (the operator in Fig. <ref>) with noise single- and two-qubit gates via Trotter decomposition (<ref>) with $H_{A} = -h\sum_{i=1}^{N}\sigma_{i}^{X}$ and $H_{B} = -J\sum_{ij}^{N}\sigma_{i}^{Z}\sigma_{j}^{Z}$. We set the final time of the forward-in-time evolution as $T = \pi$, and the echo evolution is run for time $\frac{T}{2} = \frac{\pi}{2}$ for forward and backward parts.

$q_{0}$     R_X     [2,style=fill=red!30]R_ZZ
[3,style=fill=blue!30,label style=yshift=0.0cm]R_ZZ

$q_{1}$     R_X
[3,style=fill=blue!30,label style=yshift=0.0cm]R_ZZ

$q_{2}$     R_X     [2,style=fill=red!30]R_ZZ

[3,style=fill=green!30,label style=yshift=0.0cm]R_ZZ

$q_{3}$     R_X

$q_{4}$     R_X     [2,style=fill=red!30]R_ZZ

$q_{5}$     R_X

$q_{i}$     [2]R_ZZ

$q_{i}$     1         1

$q_{j}$          R_Z(J_ijt)

(a): A single Trotter step of evolution operator of the transverse field Ising hamiltonian. Gates are grouped to layers (colors) which can be simultaneously run on a quantum device (gates do not have commonly used qubits). (b): a decomposition of $R_{ZZ}$ operator to CNOT gates and a single-qubit rotation.

§.§ Data generation

To train a neural network, we gather data from random initial states for a 6-spin system. These states are generated using a circuit in Fig. <ref>.

Every single qubit corresponds to a single spin. Every two connected qubits can be subject to a two-qubit gate, which allows the implementation of interaction between two spins.

$\ket{0_{0}}$     U_2(θ_0, ϕ_0)

$\ket{0_{1}}$     U_2(θ_1, ϕ_1)

$\ket{0_{2}}$     U_2(θ_2, ϕ_2)

$\ket{0_{3}}$     U_2(θ_3, ϕ_3)

$\ket{0_{4}}$     U_2(θ_4, ϕ_4)

$\ket{0_{5}}$     U_2(θ_5, ϕ_5)

First layer of single qubit rotation is parametrized with random angles $\theta_{j} = arccos(x)$, $x \in Uniform[-1,1]$ and $\phi_{j} \in Uniform[0,2\pi]$. CNOT gates are applied with probability $p = 0.2$ between every two connected qubits.

(a) A layout of a qubit system used in simulation in this work. (b) A quantum circuit implementing random initial states.

Here, $\theta_{j} = arccos(x)$, $x \in Uniform[-1,1]$, $\phi_{j} \in Uniform[0,2\pi]$, and “Random CNOTs” corresponds to random CNOT gates, applied to every pair of layout-connected qubits (see Fig. <ref>) with a probability $p = 0.2$.

We run simulation of echo evolution for $K = 2400$ random initial states with $5$ time points $t \in [0, \frac{\pi}{8}, \frac{\pi}{4}, \frac{3\pi}{8}, \frac{\pi}{2}]$. Using several time points allows for the production of more data, as every time point gives one data vector. For $5$ time points, every random initial state produces $5$ data vectors, which differ by the mid-evolution state at time $t$. As a result, we obtain data from evolution with different times and amounts of entanglement generated by hamiltonian (<ref>), and thus with noisy outcome data for these different entanglements.
Data generation described above resulted in $12000$ pairs of noisy and noise-free observable vectors. For a particular time point, the evolution consisted of $N$ Trotter steps forward and $N$ Trotter steps backward, with $N = 10$, and the coupling map corresponding to qubit layout (<ref>). The overall gate count of $10$ Trotter steps includes 280 CNOT gates, 140 $R_{z}$ gates, and 120 $R_{x}$ gates.

We compose data vectors of single spin magnetizations and thus have data of the dimension of the number of spins $N$.
For each initial state, we produce a vector of single spin magnetizations from measurements done before and after echo-evolution.  We obtain pairs of noisy and noise-free magnetization vectors of the form

\begin{eqnarray}
\label{magnetization_vect}
\vec{m}_{noisy} =
\begin{pmatrix}
\vspace{0.15cm}
m^{0}_{noisy} \\
\vspace{0.15cm}
m^{1}_{noisy} \\
\vspace{0.15cm}
m^{2}_{noisy} \\
\vspace{0.15cm}
m^{3}_{noisy} \\
\vspace{0.15cm}
m^{4}_{noisy} \\
\vspace{0.15cm}
\end{pmatrix}
\begin{pmatrix}
\vspace{0.15cm}
2n^{0}_{noisy} - 1 \\
\vspace{0.15cm}
2n^{1}_{noisy} - 1 \\
\vspace{0.15cm}
2n^{2}_{noisy} - 1 \\
\vspace{0.15cm}
2n^{3}_{noisy} - 1 \\
\vspace{0.15cm}
2n^{4}_{noisy} - 1 \\
\vspace{0.15cm}
2n^{5}_{noisy} - 1
\end{pmatrix},
\hspace{0.1cm}
\vec{m}_{ideal} =
\begin{pmatrix}
\vspace{0.15cm}
m^{0}_{ideal} \\
\vspace{0.15cm}
m^{1}_{ideal} \\
\vspace{0.15cm}
m^{2}_{ideal} \\
\vspace{0.15cm}
m^{3}_{ideal} \\
\vspace{0.15cm}
m^{4}_{ideal} \\
\vspace{0.15cm}
\end{pmatrix}
\begin{pmatrix}
\vspace{0.15cm}
2n^{0}_{ideal} - 1 \\
\vspace{0.15cm}
2n^{1}_{ideal} - 1 \\
\vspace{0.15cm}
2n^{2}_{ideal} - 1 \\
\vspace{0.15cm}
2n^{3}_{ideal} - 1 \\
\vspace{0.15cm}
2n^{4}_{ideal} - 1 \\
\vspace{0.15cm}
2n^{5}_{ideal} - 1
\end{pmatrix}.
\end{eqnarray}

Here, $n^{ideal}_{i} (n^{noisy}_{i})$ is an excitation number of $i$-th qubit, measured before (after) the echo-evolution.
Correspondingly, $m^{ideal}_{i} (m^{noisy}_{i})$ is a magnetization of the $i$-th spin, computed from excitation number $n^{ideal}_{i} (n^{noisy}_{i})$.

To test the performance of a trained neural network, we generate 100 random states and subject them to forward-in-time evolution from $t = 0$ to $t = \pi$. During the evolution, the system is subject to the same noise structure and level and with $N = 20$ Trotter steps to have the same circuit depth (see information about the total number of gates above).

§.§ Error model

In this work, we focused on the mitigation of gate errors. In the current state of quantum computing hardware, gate errors represent one of the main sources of errors [2] in large circuits, and most quantum error mitigation methods are first tested against this type of noise [4].
As a quantum noise model, we used single- and two-qubit depolarizing errors

\begin{eqnarray}
\label{noisemodel}
\Phi^{depol}_{1q}(\rho) = (1 - q_{1})\rho + \frac{q_{1}}{2}I, \\
\Phi^{depol}_{2q}(\rho) = (1 - q_{2})\rho + \frac{q_{2}}{4}I \otimes I
\end{eqnarray}

with noise intensities $q_{1} = 10^{-4}$ and $q_{2} = 0.01$ which correspond to state-of-the-art quantum computing capabilities [2]. We do not consider SPAM errors and decoherence in this work to provide a proof-of-principle illustration of the proposed idea.

§.§ Neural network structure, training and use

A neural network we use here is a multi-layer perceptron (see Fig. <ref>). This neural network has $N_{input} = 6$ neurons in the input layer, a single hidden layer with $N_{hidden} = 200$ neurons, and the output layer with $N_{output} = 6$ neurons. The activation function of the hidden layer (denoted $\sigma_{1}$ in Section <ref>) is ReLU

\begin{equation}
\sigma_{1}(x) = max(x, 0)
\end{equation}

and the activation function of the output layer (denoted $\sigma_{2}$ in Section <ref>) is Tanh

\begin{equation}
\sigma_{2}(x) = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}
\end{equation}

We use a mean square error (MSE) as a loss function

\begin{eqnarray}
\label{MSE}
R(\hat{W}, \hat{b}) = \frac{1}{N} \sum_{i=1}^{N}(f(\vec{x}_{i}, \hat{W}, \hat{b}) - \vec{y}_{i})^{2}
\end{eqnarray}

and minimize it using an Adam optimizer [34] with parameters $lr = 3 * 10^{-4}$, $\beta_{1} = 0.9, \beta_{2} = 0.999$. We used a batch size of $80$ data vectors. We divide $12000$ data vectors, generated via echo evolution (Section <ref>), to a training set of $8000$ vectors, a validation set of $2000$ vectors, and a testing set of $2000$ vectors. The validation set is used for “early stopping” - saving parameters $(\hat{W}, \hat{b})$ of the best-performing neural network, and the testing set is used to check if the trained network can mitigate errors in unseen echo-evolution-generated data (see Section <ref>).

^^JNeural network, shifted

^^J  Layer

ı[evaluate==̧int(ı==       ==2); =/2-ı-*̧;
=; =;] in 1,...,

[node ] (N-ı) at (,) $\Cstr[\lay]_{\index}$;

ȷin 1,...,[]

[connect,white,line width=1.2] (N-ȷ) – (N-ı);
[connect] (N-ȷ) – (N-ı);

(N2-7) –++ (0,1+) node[midway,scale=1.5] $\vdots$;

[above=0.1,align=center,myorange!60!black] at (N1-1.90) input layer
noisy input;
[above=0.1,align=center,myblue!60!black] at (N2-1.90) hidden layer;
[above=0.1,align=center,myorange!60!black] at (N-1.90) output layer
denoised output;

A neural network architecture which we use in this work. It has input layer dimension $6$, output layer dimension $6$, and a hidden layer dimension with $N_{h} = 200$ neurons. We use the ReLU activation function on a hidden layer output and the Tanh function on the output layer. Tanh function ensures correct spin magnetization values. $m_{j}$ denote spin vector components before neural network processing and $\bar{m}_{j}$ denote spin vector components after neural network processing.

The trained neural network is then used to mitigate errors in forward-in-time generated data (see Section <ref> for results).
The final goal of quantum error mitigation via a neural network is to train a neural network a mapping between noisy observable data and noise-free observable data. A trained neural network thus will do a denoising map

\begin{equation}
\vec{m}_{corrected} = f(\vec{m}_{noisy}, \hat{W}, \hat{b})
\end{equation}

for every vector $\vec{m}_{noisy}$ which we gather from a noisy quantum device.

§.§ Performance metric

To illustrate the efficiency of error mitigation, we introduce a correction efficiency value of the form

\begin{equation}
\label{correction_eff}
K =  1 - \frac{|\Delta M_{after}|}{|\Delta M_{before}|}
\end{equation}

\begin{eqnarray}
\label{DeltaM}
\Delta M_{before} = \frac{1}{N}\sum_{j}(m^{j}_{ideal} - m^{j}_{noisy})\\
\Delta M_{after} = \frac{1}{N}\sum_{j}(m^{j}_{ideal} - m^{j}_{corrected})
\end{eqnarray}

This coefficient allows illustrating the effect of error mitigation via neural network, comparing resulting observables: if $\Delta M_{after} < \Delta M_{before}$, then the observable error reduced after neural network processing; in opposite case, when $\Delta M_{after} > \Delta M_{before}$, the observable error increased after neural network processing.

§ QUANTUM ERROR MITIGATION IN ECHO EVOLUTION DATA

We train a neural network on echo-evolution-generated data and check its capability to correct data of the same kind, i.e., generated with echo evolution. We use the experiment setup described in Appendix <ref>.

In Fig. <ref>, we provide statistics of average magnetization error for 2000 test vectors.
In particular, in the test data set, we have 2000 pairs of noisy and noise-free vectors of spin magnetizations of the form $(\vec{m}_{noisy}, \vec{m}_{ideal})$ (see <ref>). From noise vectors we obtain, after applying a trained neural network for data vectors $\vec{m}_{noisy}$, 2000 corrected vectors $\vec{m}_{corrected}$. Then we calculate the differences between the average magnetization of the spin system, calculated from noise-free and noisy vectors, and noise-free and corrected vectors:

\begin{equation}
\label{deltaM}
\Delta M_{noisy(corrected)} = \frac{1}{N}\sum_{j}(m^{j}_{ideal} - m^{j}_{noisy(corrected)}),
\end{equation}

where the second vector is a noisy (neural network corrected) vector of spin magnetization. Values of $\Delta M$ are provided in Fig. <ref> (left plot), and absolute values of $\Delta M$ for every one of 2000 test states are provided in Fig. <ref> (right plot).
We see that applying a neural network leads to decreased error dispersion (left histogram) and decreased absolute error value (right scatter plot).

Left: a histogram of $\Delta M$ distribution of echo evolution results before and after error mitigation with a trained neural network.
Right: a scatter plot of $\Delta M$ for 2000 final states after echo evolution before and after error mitigation with a trained neural network. Solid lines denote average absolute values of $\Delta M$ over the test vectors dataset.

We provide correction efficiency values $K$ (see (<ref>)) for every test data vector alongside with ideal, noisy, and corrected average magnetization of the spin system in Fig. <ref> (we provide noise-free/noisy and corrected magnetization values on two separate figures for better visibility without overlapping). Here, magnetization values are sorted with respect to correction efficiency value $K$, thus there is an ascending character of $K$ value with state number in Fig. <ref>.
We can see that the neural network compensates for the shrinkage of average magnetization for most of the states in the test sample: approximately $88\%$ of states have a positive correction efficiency value $K$, which means that after applying neural network difference between corrected and ideal magnetization values decreased with respect to the difference between uncorrected and noise-free values. We note that states that are hard to correct with a neural network (negative values of $K$) have average magnetization close to zero. As depolarizing gate error leads to a decrease in the average magnetization absolute value (it tends to zero), if the ideal state has close to zero average system magnetization, its noise-corrupted magnetization is indistinguishable from the noise-free case.

Left: averaged over the chain magnetization values for 2000 final states after echo evolution with noisy evolution operator (orange) and after error mitigation with a trained neural network (blue). Values are sorted with respect to the correction efficiency parameter $K$ (black curve).
Right: averaged over the chain magnetization values for 2000 final states after echo evolution with
exact evolution operator. Values are sorted with respect to the correction efficiency parameter $K$.

§ ANALYSIS OF THE NEURAL NETWORK SIZE, CONTINUED

In the main text, we trained a neural network with a single hidden layer on data obtained from the echo evolution of the spin system. Then we demonstrated quantum error mitigation in data obtained from the forward-in-time dynamics of the spin system. For that experiment, we chose a particular size of the hidden layer (200 neurons).
In this section, we provide analysis illustrating that the number of neurons in the hidden layer can be lowered to approximately the size of data vectors.
In the following, we provide simulations for neural networks with variable width of the hidden layer and with other parts of the setup fixed - e.g., for the number of hidden layers, activation functions, loss function, and training procedure details (type of optimizer, size of data batches, etc.).

To analyze this question, we evaluate the quality of error mitigation depending on hidden layer width.
In particular, we use a trained neural network to mitigate quantum noise error in the test data set - a hold-out part of echo evolution data to evaluate error mitigation performance. For a test set of a fixed size, we can calculate statistics on error-mitigated observable values and thus see how good our trained network performs error mitigation.

We generated via echo evolution data sets (12000 pairs of noise and noise-free magnetization vectors) for different levels of two-qubit gate noise ($q_{2} = 0.003, 0.007, 0.01$). For every noise level, we did the following steps.
First, we generated $50$ random subsets of training data (6000 pairs of noise and noise-free magnetization vectors) and divided each subset into a training data set (4000 vector pairs), validation data set (1000 vector pairs), and test data set (1000 vector pairs).
Second, we chose a width of the hidden layer $N_{hidden} \in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 25, 50, 100, 200]$ and generated 50 neural network models with the same initialization of weights.
Third, we trained these neural network “clones” on 50 different data sets, each for 100 epochs. During the training, we used a batch size of 80, the Adam optimizer with learning rate $lr = 3*10^{-4}$, $\beta_{1} = 0.9$, $\beta_{2} = 0.999)$.
We used mean square error (<ref>) as a loss function.
Finally, we calculated average correction efficiency values and several statistics of $|\Delta M|$ - difference of average magnetization of spin system before and after applying a trained neural network (see <ref>).
The average was calculated over 50 different realizations of neural networks with fixed hidden layer width.
Similarly, correction efficiency values were calculated for 50 different test sets with 1000 vector pairs, and an average of over 1000 vectors generated a single value for each test data set.

In the main text in Fig. <ref>, we provided dependence of the correction efficiency (<ref>) on the width of the hidden layer for different levels of quantum noise (indicated with different values of two-qubit gates error $q_{2}$).
Here, in Fig. <ref>, we provide dependence of average magnetization difference (<ref>) on the hidden layer width.

From Fig. <ref> we can see (similar to Fig. <ref>) that the performance of quantum error mitigation becomes saturated with the hidden layer width of approximately 8 neurons. This pattern also occurs for different levels of quantum noise.

Values of observable values statistics for neural networks with different widths of the hidden layer. Average values and standard deviation are calculated over results from 50 realizations of neural networks with fixed hidden layer width. Results are provided for data with different levels of noise (indicated with different values of two-qubit gate noise $q_{2}$). Left: observable values statistics before correction with a trained neural network. Right: observable values statistics after correction with a trained neural network.

#1ISBN #1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1<https://doi.org/#1>et al.#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1<><#>1#1#1#1#1#1#1#1#1#1#1#1#1#1PreBibitemsHook

[1]

Arute, F.,
Arya, K.,
Babbush, R.,
Bacon, D.,
Bardin, J.C.,
Barends, R.,
Biswas, R.,
Boixo, S.,
Brandao, F.G.S.L.,
Buell, D.A.,
Burkett, B.,
Chen, Y.,
Chen, Z.,
Chiaro, B.,
Collins, R.,
Courtney, W.,
Dunsworth, A.,
Farhi, E.,
Foxen, B.,
Fowler, A.,
Gidney, C.,
Giustina, M.,
Graff, R.,
Guerin, K.,
Habegger, S.,
Harrigan, M.P.,
Hartmann, M.J.,
Ho, A.,
Hoffmann, M.,
Huang, T.,
Humble, T.S.,
Isakov, S.V.,
Jeffrey, E.,
Jiang, Z.,
Kafri, D.,
Kechedzhi, K.,
Kelly, J.,
Klimov, P.V.,
Knysh, S.,
Korotkov, A.,
Kostritsa, F.,
Landhuis, D.,
Lindmark, M.,
Lucero, E.,
Lyakh, D.,
Mandrà, S.,
McClean, J.R.,
McEwen, M.,
Megrant, A.,
Mi, X.,
Michielsen, K.,
Mohseni, M.,
Mutus, J.,
Naaman, O.,
Neeley, M.,
Neill, C.,
Niu, M.Y.,
Ostby, E.,
Petukhov, A.,
Platt, J.C.,
Quintana, C.,
Rieffel, E.G.,
Roushan, P.,
Rubin, N.C.,
Sank, D.,
Satzinger, K.J.,
Smelyanskiy, V.,
Sung, K.J.,
Trevithick, M.D.,
Vainsencher, A.,
Villalonga, B.,
White, T.,
Yao, Z.J.,
Yeh, P.,
Zalcman, A.,
Neven, H.,
Martinis, J.M.:
Quantum supremacy using a programmable superconducting processor.

[2]

Kim, Y.,
Eddins, A.,
Anand, S.,
Wei, K.X.,
Berg, E.,
Rosenblatt, S.,
Nayfeh, H.,
Wu, Y.,
Zaletel, M.,
Temme, K.,
Kandala, A.:
Evidence for the utility of quantum computing before fault tolerance.

[3]

Preskill, J.:
Quantum computing in the nisq era and beyond.

[4]

Cai, Z.,
Babbush, R.,
Benjamin, S.C.,
Endo, S.,
Huggins, W.J.,
Li, Y.,
McClean, J.R.,
O'Brien, T.E.:
Quantum Error Mitigation

[5]

Temme, K.,
Bravyi, S.,
Gambetta, J.M.:
Error mitigation for short-depth quantum circuits.
Physical Review Letters

[6]

Cai, Z.:
Quantum error mitigation using symmetry expansion.

[7]

Huggins, W.J.,
McArdle, S.,
O'Brien, T.E.,
Lee, J.,
Rubin, N.C.,
Boixo, S.,
Whaley, K.B.,
Babbush, R.,
McClean, J.R.:
Virtual distillation for quantum error mitigation.
Physical Review X

[8]

Cai, Z.:
A Practical Framework for Quantum Error Mitigation

[9]

Czarnik, P.,
Arrasmith, A.,
Coles, P.J.,
Cincio, L.:
Error mitigation with clifford quantum-circuit data.

[10]

Czarnik, P.,
McKerns, M.,
Sornborger, A.T.,
Cincio, L.:
Improving the efficiency of learning-based error mitigation

[11]

Lowe, A.,
Gordon, M.H.,
Czarnik, P.,
Arrasmith, A.,
Coles, P.J.,
Cincio, L.:
Unified approach to data-driven quantum error mitigation.
Physical Review Research

[12]

Zhukov, A.,
Pogosov, W.:
Quantum error reduction with deep neural network applied at the post-processing stage.
Quantum Information Processing

[13]

Lee, C.,
Park, D.K.:
Scalable quantum measurement error mitigation via conditional independence and transfer learning

[14]

Feynmann, R.:
Simulating physics with computers.
Int. J. Theor. Phys.

[15]

Manin, Y.:
Computable and noncomputable.
Russian: Sov. Radio

[16]

Smith, A.,
Kim, M.S.,
Pollmann, F.,
Knolle, J.:
Simulating quantum many-body dynamics on a current digital quantum computer.
npj Quantum Information

[17]

Mbeng, G.B.,
Russomanno, A.,
Santoro, G.E.:
The quantum Ising chain for beginners

[18]

Mi, X.,
Ippoliti, M.,
Quintana, C.,
Greene, A.,
Chen, Z.,
Gross, J.,
Arute, F.,
Arya, K.,
Atalaya, J.,
Babbush, R.,
Bardin, J.C.,
Basso, J.,
Bengtsson, A.,
Bilmes, A.,
Bourassa, A.,
Brill, L.,
Broughton, M.,
Buckley, B.B.,
Buell, D.A.,
Burkett, B.,
Bushnell, N.,
Chiaro, B.,
Collins, R.,
Courtney, W.,
Debroy, D.,
Demura, S.,
Derk, A.R.,
Dunsworth, A.,
Eppens, D.,
Erickson, C.,
Farhi, E.,
Fowler, A.G.,
Foxen, B.,
Gidney, C.,
Giustina, M.,
Harrigan, M.P.,
Harrington, S.D.,
Hilton, J.,
Ho, A.,
Hong, S.,
Huang, T.,
Huff, A.,
Huggins, W.J.,
Ioffe, L.B.,
Isakov, S.V.,
Iveland, J.,
Jeffrey, E.,
Jiang, Z.,
Jones, C.,
Kafri, D.,
Khattar, T.,
Kim, S.,
Kitaev, A.,
Klimov, P.V.,
Korotkov, A.N.,
Kostritsa, F.,
Landhuis, D.,
Laptev, P.,
Lee, J.,
Lee, K.,
Locharla, A.,
Lucero, E.,
Martin, O.,
McClean, J.R.,
McCourt, T.,
McEwen, M.,
Miao, K.C.,
Mohseni, M.,
Montazeri, S.,
Mruczkiewicz, W.,
Naaman, O.,
Neeley, M.,
Neill, C.,
Newman, M.,
Niu, M.Y.,
O'Brien, T.E.,
Opremcak, A.,
Ostby, E.,
Pato, B.,
Petukhov, A.,
Rubin, N.C.,
Sank, D.,
Satzinger, K.J.,
Shvarts, V.,
Su, Y.,
Strain, D.,
Szalay, M.,
Trevithick, M.D.,
Villalonga, B.,
White, T.,
Yao, Z.J.,
Yeh, P.,
Yoo, J.,
Zalcman, A.,
Neven, H.,
Boixo, S.,
Smelyanskiy, V.,
Megrant, A.,
Kelly, J.,
Chen, Y.,
Sondhi, S.L.,
Moessner, R.,
Kechedzhi, K.,
Khemani, V.,
Roushan, P.:
Time-crystalline eigenstate order on a quantum processor.

[19]

Chen, I.-C.,
Burdick, B.,
Yao, Y.,
Orth, P.P.,
Iadecola, T.:
Error-mitigated simulation of quantum many-body scars on quantum computers with pulse-level control.
Physical Review Research

[20]

Hatano, N.,
Suzuki, M.:
In: Das, A.,
K. Chakrabarti, B. (eds.)
Finding Exponential Product Formulas of Higher Orders,
pp. 37–68.
Berlin, Heidelberg

[21]

Kim, C.,
Park, K.D.,
Rhee, J.-K.:
Quantum error mitigation with artificial neural network.
IEEE Access

[22]

Kim, J.,
Oh, B.,
Chong, Y.,
Hwang, E.,
Park, D.K.:
Quantum readout error mitigation via deep learning.
New Journal of Physics

[23]

Babukhin, D.V.,
Pogosov, W.V.:
The effect of quantum noise on algorithmic perfect quantum state transfer on NISQ processors.
Quantum Information Processing

[24]

Tsubouchi, K.,
Sagawa, T.,
Yoshioka, N.:
Universal cost bound of quantum error mitigation based on quantum estimation theory

[25]

Dalzell, A.M.,
Hunter-Jones, N.,
Brandão, F.G.S.L.:
Random quantum circuits transform local noise into global white noise

[26]

Goodfellow, I.,
Bengio, Y.,
Courville, A.:
Deep Learning.
MIT Press

[27]

Qiskit contributors:
Qiskit: An Open-source Framework for Quantum Computing

[28]

Kay, A.:
Tutorial on the Quantikz Package

[29]

Mehta, P.,
Bukov, M.,
Wang, C.-H.,
Day, A.G.R.,
Richardson, C.,
Fisher, C.K.,
Schwab, D.J.:
A high-bias, low-variance introduction to machine learning for physicists.
Physics Reports

[30]

Palmieri, A.M.,
Kovlakov, E.,
Bianchi, F.,
Yudin, D.,
Straupe, S.,
Biamonte, J.D.,
Kulik, S.:
Experimental neural network enhanced quantum tomography.
npj Quantum Information

[31]

Neugebauer, M.,
Fischer, L.,
Jäger, A.,
Czischek, S.,
Jochim, S.,
Weidemüller, M.,
Gärttner, M.:
Neural-network quantum state tomography in a two-qubit experiment.
Physical Review A

[32]

Bukov, M.,
Day, A.G.R.,
Sels, D.,
Weinberg, P.,
Polkovnikov, A.,
Mehta, P.:
Reinforcement learning in different phases of quantum control.
Physical Review X

[33]

Nielsen, M.A.:
Neural Networks and Deep Learning.
Determination Press

[34]

Kingma, D.P.,
Ba, J.:
Adam: A Method for Stochastic Optimization

#1ISBN #1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1<https://doi.org/#1>et al.#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1#1<><#>1#1#1#1#1#1#1#1#1#1#1#1#1#1PreBibitemsHook

[1]

Arute, F.,
Arya, K.,
Babbush, R.,
Bacon, D.,
Bardin, J.C.,
Barends, R.,
Biswas, R.,
Boixo, S.,
Brandao, F.G.S.L.,
Buell, D.A.,
Burkett, B.,
Chen, Y.,
Chen, Z.,
Chiaro, B.,
Collins, R.,
Courtney, W.,
Dunsworth, A.,
Farhi, E.,
Foxen, B.,
Fowler, A.,
Gidney, C.,
Giustina, M.,
Graff, R.,
Guerin, K.,
Habegger, S.,
Harrigan, M.P.,
Hartmann, M.J.,
Ho, A.,
Hoffmann, M.,
Huang, T.,
Humble, T.S.,
Isakov, S.V.,
Jeffrey, E.,
Jiang, Z.,
Kafri, D.,
Kechedzhi, K.,
Kelly, J.,
Klimov, P.V.,
Knysh, S.,
Korotkov, A.,
Kostritsa, F.,
Landhuis, D.,
Lindmark, M.,
Lucero, E.,
Lyakh, D.,
Mandrà, S.,
McClean, J.R.,
McEwen, M.,
Megrant, A.,
Mi, X.,
Michielsen, K.,
Mohseni, M.,
Mutus, J.,
Naaman, O.,
Neeley, M.,
Neill, C.,
Niu, M.Y.,
Ostby, E.,
Petukhov, A.,
Platt, J.C.,
Quintana, C.,
Rieffel, E.G.,
Roushan, P.,
Rubin, N.C.,
Sank, D.,
Satzinger, K.J.,
Smelyanskiy, V.,
Sung, K.J.,
Trevithick, M.D.,
Vainsencher, A.,
Villalonga, B.,
White, T.,
Yao, Z.J.,
Yeh, P.,
Zalcman, A.,
Neven, H.,
Martinis, J.M.:
Quantum supremacy using a programmable superconducting processor.

[2]

Kim, Y.,
Eddins, A.,
Anand, S.,
Wei, K.X.,
Berg, E.,
Rosenblatt, S.,
Nayfeh, H.,
Wu, Y.,
Zaletel, M.,
Temme, K.,
Kandala, A.:
Evidence for the utility of quantum computing before fault tolerance.

[3]

Preskill, J.:
Quantum computing in the nisq era and beyond.

[4]

Cai, Z.,
Babbush, R.,
Benjamin, S.C.,
Endo, S.,
Huggins, W.J.,
Li, Y.,
McClean, J.R.,
O'Brien, T.E.:
Quantum Error Mitigation

[5]

Temme, K.,
Bravyi, S.,
Gambetta, J.M.:
Error mitigation for short-depth quantum circuits.
Physical Review Letters

[6]

Cai, Z.:
Quantum error mitigation using symmetry expansion.

[7]

Huggins, W.J.,
McArdle, S.,
O'Brien, T.E.,
Lee, J.,
Rubin, N.C.,
Boixo, S.,
Whaley, K.B.,
Babbush, R.,
McClean, J.R.:
Virtual distillation for quantum error mitigation.
Physical Review X

[8]

Cai, Z.:
A Practical Framework for Quantum Error Mitigation

[9]

Czarnik, P.,
Arrasmith, A.,
Coles, P.J.,
Cincio, L.:
Error mitigation with clifford quantum-circuit data.

[10]

Czarnik, P.,
McKerns, M.,
Sornborger, A.T.,
Cincio, L.:
Improving the efficiency of learning-based error mitigation

[11]

Lowe, A.,
Gordon, M.H.,
Czarnik, P.,
Arrasmith, A.,
Coles, P.J.,
Cincio, L.:
Unified approach to data-driven quantum error mitigation.
Physical Review Research

[12]

Zhukov, A.,
Pogosov, W.:
Quantum error reduction with deep neural network applied at the post-processing stage.
Quantum Information Processing

[13]

Lee, C.,
Park, D.K.:
Scalable quantum measurement error mitigation via conditional independence and transfer learning

[14]

Feynmann, R.:
Simulating physics with computers.
Int. J. Theor. Phys.

[15]

Manin, Y.:
Computable and noncomputable.
Russian: Sov. Radio

[16]

Smith, A.,
Kim, M.S.,
Pollmann, F.,
Knolle, J.:
Simulating quantum many-body dynamics on a current digital quantum computer.
npj Quantum Information

[17]

Mbeng, G.B.,
Russomanno, A.,
Santoro, G.E.:
The quantum Ising chain for beginners

[18]

Mi, X.,
Ippoliti, M.,
Quintana, C.,
Greene, A.,
Chen, Z.,
Gross, J.,
Arute, F.,
Arya, K.,
Atalaya, J.,
Babbush, R.,
Bardin, J.C.,
Basso, J.,
Bengtsson, A.,
Bilmes, A.,
Bourassa, A.,
Brill, L.,
Broughton, M.,
Buckley, B.B.,
Buell, D.A.,
Burkett, B.,
Bushnell, N.,
Chiaro, B.,
Collins, R.,
Courtney, W.,
Debroy, D.,
Demura, S.,
Derk, A.R.,
Dunsworth, A.,
Eppens, D.,
Erickson, C.,
Farhi, E.,
Fowler, A.G.,
Foxen, B.,
Gidney, C.,
Giustina, M.,
Harrigan, M.P.,
Harrington, S.D.,
Hilton, J.,
Ho, A.,
Hong, S.,
Huang, T.,
Huff, A.,
Huggins, W.J.,
Ioffe, L.B.,
Isakov, S.V.,
Iveland, J.,
Jeffrey, E.,
Jiang, Z.,
Jones, C.,
Kafri, D.,
Khattar, T.,
Kim, S.,
Kitaev, A.,
Klimov, P.V.,
Korotkov, A.N.,
Kostritsa, F.,
Landhuis, D.,
Laptev, P.,
Lee, J.,
Lee, K.,
Locharla, A.,
Lucero, E.,
Martin, O.,
McClean, J.R.,
McCourt, T.,
McEwen, M.,
Miao, K.C.,
Mohseni, M.,
Montazeri, S.,
Mruczkiewicz, W.,
Naaman, O.,
Neeley, M.,
Neill, C.,
Newman, M.,
Niu, M.Y.,
O'Brien, T.E.,
Opremcak, A.,
Ostby, E.,
Pato, B.,
Petukhov, A.,
Rubin, N.C.,
Sank, D.,
Satzinger, K.J.,
Shvarts, V.,
Su, Y.,
Strain, D.,
Szalay, M.,
Trevithick, M.D.,
Villalonga, B.,
White, T.,
Yao, Z.J.,
Yeh, P.,
Yoo, J.,
Zalcman, A.,
Neven, H.,
Boixo, S.,
Smelyanskiy, V.,
Megrant, A.,
Kelly, J.,
Chen, Y.,
Sondhi, S.L.,
Moessner, R.,
Kechedzhi, K.,
Khemani, V.,
Roushan, P.:
Time-crystalline eigenstate order on a quantum processor.

[19]

Chen, I.-C.,
Burdick, B.,
Yao, Y.,
Orth, P.P.,
Iadecola, T.:
Error-mitigated simulation of quantum many-body scars on quantum computers with pulse-level control.
Physical Review Research

[20]

Hatano, N.,
Suzuki, M.:
In: Das, A.,
K. Chakrabarti, B. (eds.)
Finding Exponential Product Formulas of Higher Orders,
pp. 37–68.
Berlin, Heidelberg

[21]

Kim, C.,
Park, K.D.,
Rhee, J.-K.:
Quantum error mitigation with artificial neural network.
IEEE Access

[22]

Kim, J.,
Oh, B.,
Chong, Y.,
Hwang, E.,
Park, D.K.:
Quantum readout error mitigation via deep learning.
New Journal of Physics

[23]

Babukhin, D.V.,
Pogosov, W.V.:
The effect of quantum noise on algorithmic perfect quantum state transfer on NISQ processors.
Quantum Information Processing

[24]

Tsubouchi, K.,
Sagawa, T.,
Yoshioka, N.:
Universal cost bound of quantum error mitigation based on quantum estimation theory

[25]

Dalzell, A.M.,
Hunter-Jones, N.,
Brandão, F.G.S.L.:
Random quantum circuits transform local noise into global white noise

[26]

Goodfellow, I.,
Bengio, Y.,
Courville, A.:
Deep Learning.
MIT Press

[27]

Qiskit contributors:
Qiskit: An Open-source Framework for Quantum Computing

[28]

Kay, A.:
Tutorial on the Quantikz Package

[29]

Mehta, P.,
Bukov, M.,
Wang, C.-H.,
Day, A.G.R.,
Richardson, C.,
Fisher, C.K.,
Schwab, D.J.:
A high-bias, low-variance introduction to machine learning for physicists.
Physics Reports

[30]

Palmieri, A.M.,
Kovlakov, E.,
Bianchi, F.,
Yudin, D.,
Straupe, S.,
Biamonte, J.D.,
Kulik, S.:
Experimental neural network enhanced quantum tomography.
npj Quantum Information

[31]

Neugebauer, M.,
Fischer, L.,
Jäger, A.,
Czischek, S.,
Jochim, S.,
Weidemüller, M.,
Gärttner, M.:
Neural-network quantum state tomography in a two-qubit experiment.
Physical Review A

[32]

Bukov, M.,
Day, A.G.R.,
Sels, D.,
Weinberg, P.,
Polkovnikov, A.,
Mehta, P.:
Reinforcement learning in different phases of quantum control.
Physical Review X

[33]

Nielsen, M.A.:
Neural Networks and Deep Learning.
Determination Press

[34]

Kingma, D.P.,
Ba, J.:
Adam: A Method for Stochastic Optimization