What is my quantum computer good for? Quantum capability learning with physics-aware neural networks

A quantum computer performs computations using qubits, which are two-level systems whose pure states are unit vectors in a complex two-dimensional Hilbert space, $\mathcal{H}$. The pure states of $n$ qubits are unit vectors in $\mathcal{H}^{\otimes n}$. The two orthonormal vectors ${\left|0\right\rangle}$ and ${\left|1\right\rangle}$ that are eigenvectors of the $Z$ Pauli operator are identified as the computational basis of $\mathcal{H}$. Errors and noise in real quantum computers mean that they are typically in states $\rho$ that are probabilistic mixtures of pure states.

A quantum computation is performed by running a quantum program, typically known as a quantum circuit (see illustration in Fig. 1a). An $n$-qubit quantum circuit ($c$) of depth $d$ is defined by a sequence of $d$ layers of logical instructions $\{L_{i}\}$. Executing $c$ consists of preparing each qubit in ${\left|0\right\rangle}$, applying each $L_{i}$, and then measuring each qubit to obtain an $n$-bit string $b$. Each layer typically consists of parallel one- and two-qubit gates, and it is intended to implement a $2^{n}\times 2^{n}$ unitary $U(L_{i})$. Together, the layers are intended to implement $U(c)=U(L_{d})\cdots U(L_{1})$.

If quantum circuit $c$ is implemented without error, its output bit string $b$ is a sample from a distribution $\textrm{P}(c)$ whose probabilities are given by $\textrm{Pr}(b=x)=|\langle x|U(c){\left|00\cdots 0\right\rangle}|^{2}$ where ${\left|00\cdots 0\right\rangle}={\left|0\right\rangle}\otimes\cdots\otimes{\left|0\right\rangle}$, ${\left|x\right\rangle}={\left|x_{1}\right\rangle}\otimes\cdots\otimes{\left|x_{n}\right\rangle}$, and $x_{i}$ is the $i$-th bit in $x$. However, when a circuit is executed on a real quantum computer, errors can occur and this means that its output bit string $b$ is a sample from some other distribution $\tilde{\textrm{P}}(c)$. The process of errors corrupting a quantum computation can be modelled as follows. Each logic layer $L_{i}$ implements the intended unitary superoperator $\mathcal{U}(L_{i}):\rho\to U(L_{i})\rho U^{\dagger}(L_{i})$, where $\rho$ is a general $n$-qubit state, followed by an error channel $\Lambda_{i}$ that is a completely positive and trace preserving (CPTP) superoperator [Blume-Kohout et al., 2022]. The imperfect implementation of a circuit $c$ is then simply $\tilde{\mathcal{U}}(c)=\prod_{i=1}^{d}\Lambda_{i}\circ\mathcal{U}(L_{i})$, and the output bit string $b$ is $x$ with probability $\textrm{Pr}(b=x)=\textrm{Tr}({\left|x\right\rangle}\langle x|\tilde{\mathcal{U}}(c)[{\left|00\cdots 0\right\rangle}\langle 00\cdots 0|])$.

Because quantum computers are error-prone, knowing which quantum circuits a particular quantum computer can execute with low error probability is important. Known as quantum capability learning [Proctor et al., 2021a, Hothem et al., 2023c], this task formally involves learning the mapping between a set of quantum circuits $c\in\mathcal{C}$ and some success metric $s(c)\in\mathbb{R}$ quantifying how well $c$ runs on a quantum computer $\mathcal{Q}$. In this work we consider a large class of circuits known as Clifford (or stabilizer) circuits [Aaronson and Gottesman, 2004], which are sufficient to enable quantum error correction [Campbell et al., 2017], and two widely-used success metrics: probability of successful trial (PST) (a.k.a., success probability) and the process fidelity (a.k.a. entanglement fidelity) [Hothem et al., 2023c, Nielsen, 2002].

PST is defined only for definite-outcome circuits, which are circuits whose output distribution has (if run without error) support on a single bit string, $b(c)$. For any such circuit $c$, PST is defined as

$$\mathrm{PST}(c)=\mathrm{Pr}(\mathrm{measuring\ }b(c)\mathrm{\ when\ executing\ }c\mathrm{\ on\ }\mathcal{Q}).$$

(1)

In practice, $\mathrm{PST}(c)$ is estimated by running the circuit $N_{\mathrm{shots}}\gg 1$ times on $\mathcal{Q}$ and calculating

$$\widehat{\mathrm{PST}(c)}=\frac{\#\mathrm{\ observations\ of\ }b(c)}{N_{\mathrm{shots}}}.$$

(2)

Process fidelity is defined for all circuits, and it quantifies how close the actual quantum evolution of the qubits is to the ideal unitary evolution. It is given by

$$F(c)=\frac{1}{4^{n}}\textrm{Tr}\left[\tilde{\mathcal{U}}(c)\mathcal{U}^{-1}(c)\right].$$

(3)

Estimating $F(c)$ is more complicated than estimating $\mathrm{PST}(c)$ (it requires embedding $c$ into other circuits), but efficient methods exist [Proctor et al., 2022].

Our qpa-NNs build in efficient approximations to the quantum physics of errors in quantum computers. They do so using the following parameterization of an error channel: $\Lambda=\exp(\sum_{j}\epsilon_{j}G_{j})$. Here $\mathbb{G}_{n}=\{G_{j}\}$ is the set of $2^{2n+1}-2$ different Hamiltonian (H) and Stochastic (S) elementary error generators introduced by Blume-Kohout et al. [2022], and $\epsilon_{j}$ is the rate of error $G_{j}$. Not every kind of error process can be represented in this form (e.g., amplitude damping, or non-Markovian errors), but this parameterization includes many of the most important kinds of errors in contemporary quantum computers. Each H and S error generator is indexed by a non-identity element of the $n$-qubit Pauli group ($\mathbb{P}_{n}$). The Pauli operator indexing an H or S error indicates the qubits it impacts and its direction, e.g., the H error generator indexed by $X\otimes I^{\otimes(n-1)}$ is a coherent error on the 1^st qubit and it rotates that qubit around its $X$ axis.

Our qpa-NNs use approximate formulas for computing $\mathrm{PST}(c)$ or $F(c)$ from the rates of H and S errors, which we now review. Consider pushing each error channel $\Lambda_{i}$ to the end of the circuit and combining them together, i.e., we compute the error channel $\Lambda(c)$ defined by $\tilde{\mathcal{U}}(c)=\Lambda(c)\circ\mathcal{U}(c)$. Then

$$\mathrm{PST}(c)\approx 1-\sum_{P\in\mathbb{P}^{X,Y}_{n}}\Big{(}s_{P}+\theta^{2}_{p}\Big{)},$$

(4)

where $s_{P}$ and $\theta_{P}$ are the rates of the $P$-indexed $S$ and $H$ error generators, respectively, in $c$’s error channel $\Lambda(c)$, and $\mathbb{P}^{X,Y}_{n}$ is the set of $n$-qubit Pauli operators containing at least one $X$ or $Y$. Similarly,

$$F(c)\approx 1-\sum_{P\in\mathbb{P}_{n}}\Big{(}s_{P}+\theta^{2}_{p}\Big{)}.$$

(5)

Equations (4) and (5) are good approximations for low-error circuits [Mądzik et al., 2022].

The neural network $\mathcal{N}$’s input is a quantum circuit $c$ of depth $d(c)$ represented by (i) a tensor $I(c)\in\{0,1\}^{n\times d(c)\times n_{ch}}$ describing the gates in $c$ (see Fig. 1a), and (ii) a matrix $M(c)\in\{0,1\}^{2\times n}$ describing the measurement of the qubits at the end of $c$. $\mathcal{N}$ maps $I(c)$ to a matrix $\mathcal{E}\in\mathbb{R}^{k\times d(c)}$ and $M(c)$ to a vector $\vec{m}\in\mathbb{R}^{k}$. $\mathcal{E}_{ij}$ is a prediction for the rate with which error type $j$ occurs during circuit layer $i$, and $m_{j}$ is a prediction for the rate with which error type $j$ occurs when measuring the qubits at the end of a circuit. There are $2(4^{n}-1)$ different possible error types that can occur in principle (see Section 2) so it is infeasible to predict all their rates beyond very small $n$. However, the overwhelming majority of these errors are implausible, i.e., they are not expected to occur in real quantum computers [Blume-Kohout et al., 2022]. Our networks therefore predict the rates of every error from a relatively small set of error types $\mathbb{G}=\{G_{1},\dots,G_{k}\}$ containing the $k$ most plausible kinds of error. $\mathbb{G}$ is a hyperparameter of our networks. It can be chosen to reflect the known physics of a particular quantum computer and/or optimized using hyperparameter tuning. In our demonstrations, we choose $\mathbb{G}$ to contain all one-body H and S errors as well as all two-body H and S errors that interact pairs of qubits within $h$ steps on the modelled quantum computer’s connectivity graph for some constant $h$ (see Fig. 1b-c, where Fig. 1c shows an H or S error in $\mathbb{G}$ if $h\geq 2$). This choice for $\mathbb{G}$ encodes the physical principles that errors are primarily either localized to a qubit or are two-body interactions between nearby qubits [Blume-Kohout et al., 2022]. The size of $\mathbb{G}$ grows with $n$, and for planar connectivity graphs (as in, e.g., contemporary superconducting qubit systems [Arute et al., 2019]) it grows linearly in $n$. This results in $k=\mathcal{O}(n)$ errors whose rates $\mathcal{N}$ must learn to predict.

The internal structures of $\mathcal{N}$ are chosen to reflect general physical principles for how $\mathcal{E}$ and $\vec{m}$ depend on $c$. $\mathcal{E}_{ij}$ is a prediction for the rate that $G_{j}$ occurs in circuit layer $i$, and this error corresponds to a space/time location within $c$—because it occurs at layer index or time $i$ and $G_{j}$ acts on a subset of the qubits $Q(G_{j})$ (see example in Fig. 1c). This error’s rate will therefore primarily depend only on the gates in a time- and space-local region around its location in $c$. Furthermore this dependence will typically be invariant under time translations (this is true except for some exotic non-Markovian kinds of errors, that we discuss in Section 7.1). We can encode these structures into $\mathcal{N}$ by predicting $\mathcal{E}_{ij}$ from a space-time “window” of $c$ around the associated error’s location using a filter $W_{j}$ that “slides” across the circuit to predict the rate of $G_{j}$ versus time $i$. Stated more formally, we predict $\mathcal{E}_{ij}$ using a multilayer perceptron $\mathcal{N}_{j}$ whereby $\mathcal{N}_{j}(W_{j}[I(c),i])=\mathcal{E}_{ij}$ and $W_{j}[I(c),i]$ is a snippet of $I(c)$ whose temporal origin is $i$ (see Fig. 1e). The shape of each filter $W_{j}$ is a hyperparameter of our networks and it can be designed to reflect general physical principles, the known physics of a particular quantum computing system, and/or optimized with hyperparameter tuning. The particular neural networks we present later herein use filters $W_{j}(I(c),i)$ that snip out only layer $i$ and discard the parts of the layer that act on qubits more than $l$ steps away from $Q(G_{j})$ in the quantum computer’s connectivity graph (e.g., the filter shown in Fig. 1e corresponds to the error shown in Fig. 1c and $l=1$). This neural network structure has close connections to graph convolution layers [Kipf and Welling, 2016], as well as CNNs. We choose this structure as it can model spatially localized crosstalk errors, which are a ubiquitous but hard-to-model class of errors in quantum computers [Sarovar et al., 2020].

The network $\mathcal{N}$ must also predict the rates of errors that occur during measurements (unless the qpa-NN will only ever predict $F(c)$ not $\mathrm{PST}(c)$), but these are typically independent of the rates of gate errors (which are predicted by the $\mathcal{N}_{j}$). So we do not use the $\mathcal{N}_{j}$ and their convolutional filters $W_{j}$ to make predictions for $\vec{m}$. Instead we use separate but structurally equivalent networks $\mathcal{N}^{\prime}_{j}$ with corresponding filters $W^{\prime}_{j}$ that take $M(c)$ as input and implement only spatial filtering. That is, $W^{\prime}_{j}$ simply discard rows from $M(c)$, as, unlike $I(c)$, $M(c)$ has no temporal dimension. The $W_{j}^{\prime}$ are hyperparameters of our networks and we can separately adjust the shape of each $W^{\prime}_{j}$ to reflect the known physics of errors induced by measuring qubits. In our demonstrations, our $W_{j}^{\prime}$ filters have the same structure as the $W_{j}$ filters but with an independent $l^{\prime}$ steps parameter (large $l^{\prime}$ enables modelling many-qubit measurement crosstalk).

We process $\mathcal{N}$’s output to predict $\mathrm{PST}(c)$ or $F(c)$ using a function $f$ with no learnable parameters. This turns $\mathcal{N}$’s output into the two quantities of interest, and it is also makes training $\mathcal{N}$ feasible. We cannot easily train $\mathcal{N}$ in isolation because the error matrix $\mathcal{E}$ predicted by $\mathcal{N}$ is not a directly observable quantity. Generating the data needed to train $\mathcal{N}$ directly would require extraordinarily expensive quantum process tomography [Nielsen et al., 2021], which is infeasible except for very small $n$. In contrast, both $\mathrm{PST}(c)$ and $F(c)$ can be efficiently estimated (see Section 2) for a given circuit $c$.

The function $f$ computes an approximation to the value for $\mathrm{PST}(c)$ or $F(c)$ predicted by $\mathcal{E}$ and $\vec{m}$. The matrix $\mathcal{E}$ encodes the prediction that $c$’s imperfect action is

$$\tilde{\mathcal{U}}(c)=\Lambda_{d}(\mathcal{E})\mathcal{U}(L_{d})\cdots\Lambda_{1}(\mathcal{E})\mathcal{U}(L_{1}),$$

(6)

where the $L_{i}$ are the $d$ layers of $c$ (see Section 2) and $\Lambda_{i}(\mathcal{E})=\exp(\sum_{j=1}^{k}\mathcal{E}_{ij}G_{j})$, i.e., $\Lambda_{i}(\mathcal{E})$ is an error channel parameterized by the $i$^th column of $\mathcal{E}$. Equation (6) implies an exact prediction for $\mathrm{PST}(c)$ or $F(c)$ [e.g., Eq. (3)], but exactly computing that prediction involves explicitly creating and multiplying together each of the $4^{n}\times 4^{n}$ matrices in Eq. (6). This is infeasible, except for very small $n$. Instead our $f$ computes an efficient approximation to this prediction.

Our function $f$’s action is most easily described by embedding $\mathcal{E}$ into the space of all possible H and S errors $\mathbb{G}_{n}$, resulting in a $d\times(2^{2n+1}-2)$ matrix $\mathcal{E}_{e}$ whose columns are $k$-sparse. However, we never construct these exponentially large matrices. Consider pulling each error channel to the end of the circuit, giving $\tilde{\mathcal{U}}(c)=\Lambda_{d}^{\prime}(\mathcal{E}_{e}^{\prime})\cdots\Lambda_{1}^{\prime}(\mathcal{E}_{e}^{\prime})\mathcal{U}(c)$ where $\Lambda_{d}^{\prime}(\mathcal{E}_{e}^{\prime})=\exp(\sum_{j=1}^{2^{2n+1}-2}[\mathcal{E}_{e}^{\prime}]_{ij}G_{j})$. Because $c$ contains only Clifford gates and Clifford unitaries preserve the Pauli group [Aaronson and Gottesman, 2004], $\mathcal{E}_{e}^{\prime}$ has columns that are just $c$-dependent signed permutations of $\mathcal{E}_{e}$’s columns. The signed permutations required can be efficiently computed in advance (i.e., as an input encoding step) using an efficient representation of Clifford unitaries [Gidney, 2021]. Furthermore, these permutations can be efficiently represented in two $d\times k$ matrices: a sign matrix $S(c)$ containing $\pm 1$ signs to be element-wise multiplied with $\mathcal{E}$ and a permutation indices matrix $P(c)$ containing integers between 1 and $2^{2n+1}-2$, where $P_{ij}$ specifies what error $G_{j}$ becomes when pulled through the $d-i$ circuit layers after layer $i$.

We now have a representation of $\mathcal{E}$’s prediction for the circuit $c$’s error map $\Lambda(c)$ as a sequence of error maps $\Lambda_{d}^{\prime}(\mathcal{E}_{e}^{\prime})\cdots\Lambda_{1}^{\prime}(\mathcal{E}_{e}^{\prime})$, and we need to predict $\mathrm{PST}(c)$ or $F(c)$. We can do so if we can compute $\mathcal{E}$’s prediction for the S and H error rates in $\Lambda(c)$, as we can then apply Eq. (4) or Eq. (5). To achieve this, we combine the $\Lambda_{i}^{\prime}(\mathcal{E})$ into a single error map using a first-order Baker-Campbell-Hausdorff (BCH) expansion. Using our embedded representation, this means simply approximating $\Lambda(c)$ as $\Lambda(c)\approx\exp(\sum_{j}v_{j}G_{j}^{\prime})$ where $v_{j}=\sum_{i=1}^{d}[\mathcal{E}_{e}^{\prime}]_{ij}$, i.e., we sum over the rows of $\mathcal{E}_{e}^{\prime}$. To predict $F(c)$ we then simply apply Eq. (4) (meaning summing up $v_{j}$ with those elements that correspond to Hamiltonian errors squared). Because measurement errors impact $\mathrm{PST}(c)$, to predict $\mathrm{PST}(c)$ we again apply the BCH expansion to combine in the predicted measurement error map $\exp(\sum_{j=1}^{l}m_{j}G_{j})$ and then apply Eq. (5). The efficient representation of the overall action of $f$ is illustrated in Fig. 1 (the addition of the measurement error map is not shown).

We used the 5-qubit datasets in Hothem et al. [2023c] for our experimental demonstrations. Each of these datasets $D=\{(c,\widehat{\mathrm{PST}(c)})\}$ was gathered by running random and periodic mirror circuits (two types of definite-outcome circuits) on 5-qubit IBM Q computers ($\mathtt{ibmq\_london}$, $\mathtt{ibmq\_essex}$, $\mathtt{ibmq\_burlington}$, $\mathtt{ibmq\_vigo}$, $\mathtt{ibmq\_ourense}$ and $\mathtt{ibmq\_yorktown}$), and estimating the PST of each circuit using Eq. (2). Each circuit was run between $1024$ and $4096$ times, with the exact number depending upon how many times the circuit sampling process generated the circuit (some short, $1$-qubit circuits were generated multiple times). The random and periodic mirror circuits contained between $1$ and $5$ active qubits—called the circuit’s width—and ranged in depth from $3$ to $515$ layers (alt. $259$ for the $\mathtt{ibmq\_yorktown}$ dataset).

In this work we focus on high-PST circuits, so we removed all circuits with a PST less than $85\%$ from each dataset, leaving between $864$ ($\mathtt{ibmq\_burlington}$) and 1369 ($\mathtt{ibmq\_yorktown}$) circuits in each dataset. The remaining circuits were partitioned into training, validation, and test sets based upon their original assignment in Hothem et al. [2023c]. This setup enables a direct comparison between our qpa-NNs and the CNNs trained in Hothem et al. [2023c]. Training set sizes ranged from $682$ circuits on $\mathtt{ibmq\_burlington}$ to $1097$ circuits on $\mathtt{ibmq\_yorktown}$, with an approximate training, validation, testing split of $80\%$, $10\%$, and $10\%$, respectively.

For our simulations, we generated 5 datasets of $5000$ high-fidelity ($F(c)>85\%$) random circuits, for a hypothetical 4-qubit processor with a “ring” geometry (i.e., like that in Fig. 1b). The circuits ranged in width ($w$) from $1$ to $4$ qubits, and in depth from 1 to 180 circuit layers. Each circuit was designed for a randomly chosen subset of $w$ qubits. Each circuit layer was created by i.i.d. sampling from all possible circuit layers on the $w$ active qubits. We used a gate set containing two-qubit $\mathrm{CNOT}$ gates and 7 different single-qubit gates (specifically $\{X(\pi/2),Y(\pi/2),X(3\pi/2),Y(3\pi/2),X(\pi),Y(\pi),Z(\pi)\}$ where $P(\theta)$ denotes a rotation around the $P$ axis by $\theta$). See Appendix C for additional details.

All circuits were simulated under the same error model, consisting of local coherent (i.e., H) errors, to exactly compute each $c$’s $F(c)$ [Fig. 3 shows a histogram of $F(c)$]. After removing duplicate circuits, the resulting datasets $D=\{(c,F(c))\}$ were partitioned into training, validation, and testing subsets, with a partition of $56.25\%$, $18.75\%$, and $25\%$, respectively. The parameters of the error model were randomly selected: each gate was assigned a small error strength, which was then distributed randomly across all possible (local) one- or two-qubit coherent errors, for the one- and two-qubit gate, respectively. We chose a model with only coherent errors as these errors are ubiquitous, they are hard to model accurately and efficiently, and we conjecture that qpa-NNs can model them.

We also generated 5 datasets of 750 random mirror circuits on the same hypothetical quantum computer. Again, random mirror circuits varied in width from $1$ to $4$ qubits, and were designed to be run on a randomly selected subset of $w$ qubits. However, instead of i.i.d. sampling of each circuit layer, each circuit was randomly sampled from the class of random mirror circuits on the $w$ qubits. The depth of the mirror circuits ranged from 8 to 174 layers. We generated the mirror circuit datasets to evaluate how well qpa-NNs and CNNs generalize to out-of-distribution circuits, so they were used exclusively as testing sets. To ensure that no training was performed on mirror circuits, we removed any mirror circuits that appeared in the random circuit sets (in actuality, there were no duplicates).

We used two different encoding schemes for converting each circuit $c$ into a tensor. For the CNNs on experimental data, we used the same encoding scheme as Hothem et al. [2023c], as we used their data and networks. For all qpa-NNs, and the CNNs on simulated data, we used the following scheme. As outlined in Section 3, each width-$w$ circuit $c$ is represented by a three-dimensional tensor $I(c)\in\{0,1\}^{n\times d(c)\times n_{ch}}$ describing the gates in $c$ and a matrix $M(C)\in\{0,1\}^{2\times w}$ describing the measurement of the qubits. The $ij$-th entry of $I(c)$,

$$I_{ij}(c)=(I_{ij1}(c),\ldots,I_{ijn_{ch}}(c)),$$

(7)

is a one-hot encoded vector of what happens to qubit $i$ in layer $j$. For the hypothetical 4-qubit ring processor, $n_{ch}=11$: one channel for each single-qubit gate and four channels for the CNOT gates. There are four CNOT channels to specify if the qubit $i$ is the target or control qubit and if the interacting qubit is to the left or right of qubit $i$. We used an additional 4 or 8 CNOT channels for the experimental data, depending on the quantum computer’s geometry. The first row in $M(c)$ is the bitstring specifying which qubits are measured at the end of $c$. When $c$ is a definite-outcome circuit, the second row is its target bit string, i.e., the sole bit string in the support of $c$’s outcome distribution when it is executed without error [i.e., $\textrm{P}(c)$]. Both $I(c)$ and $M(c)$ are zero-padded to ensure a consistent tensor shape across a dataset.

Additionally, each circuit $c$ is accompanied by a permutation matrix $P(c)\in\mathbb{N}^{n\times k}$ and sign matrix $S(c)\in\{\pm 1\}^{n\times k}$. The $ij$-entry of $P(c)$ specifies which error the $j$-th tracked error occurring after the $i$-th layer is transformed into at the end of the circuit. The $ij$-th entry of $S(c)$ specifies the sign of that error.

Our results are a significant improvement over the state of the art, but our approach does have several limitations:

1. 1.

   As presently conceived, our approach assumes that the modelled quantum computer’s error rates are invariant under time translations, which is a kind of Markovianity assumption (although it is weaker than the typical Markovian assumption used in conventional quantum computer models [Nielsen et al., 2021]). However, non-Markovian noise exists in quantum computers [White et al., 2020]. In the future, we plan to address this issue by adding temporal information into our approach, perhaps with a temporal or positional encoding [Vaswani et al., 2017].

2. 2.

   Our approach only considers two error classes (H and S errors). Other Markovian error classes, like amplitude damping, exist, but their error rates $\varepsilon$ contribute to PST and fidelity at order $\mathcal{O}(\varepsilon^{3})$ [Mądzik et al., 2022]. Our approach can be easily extended to include those errors, if necessary, by learning their rates with $\mathcal{N}$ and updating $f$ to account for their presence.

3. 3.

   Our current approach works for Clifford circuits, which includes arguably the most important kinds of circuits (e.g., quantum error correction circuits) but not all interesting circuits. This is because our method for efficiently propagating errors through circuits (implemented by $f$ together with the $S$ and $P$ matrices) leverages the elegant mathematics of Clifford circuits. Our approach can be easily extended to generic few-qubit quantum circuits ($\lesssim 10$ qubits), but to obtain the efficiency needed for large $n$ with general circuits we will need to develop approximate methods for propagating errors through those circuits.

In this paper, we presented a new quantum-physics-aware neural network architecture for modelling a quantum computer’s capability that significantly improves upon the state of the art. The new architecture concatenates two parts: (i) a neural network with structural similarities to GNNs that uses gate information and a quantum computer’s connectivity graph to predict the rates of errors in each of a circuit’s layers, and (ii) a non-trainable function that turns the predicted error rates into a capability prediction. By imbuing these networks with knowledge about how errors occur and combine within a circuit, we are able to outperform state-of-the-art CNN-based capability models by $\sim 50\%$ on both experimental data and simulated data. We also provided evidence that our quantum-physics-aware networks are learning the true physical error rates, as they exhibit modest prediction accuracy when predicting the fidelity of out-of-distribution quantum circuits, which would enable our networks to also be used to diagnose the error processes occurring in a particular quantum computer (an important task known as characterization or tomography [Nielsen et al., 2021]).

Understanding which quantum circuits a quantum computer can run, and how well it can run them, is an important yet challenging component of understanding a quantum computer’s power. Given the complexity of the problem, neural networks are likely to play a large role in its solution. As our results demonstrate, our new physics-aware network architecture could play a critical role in building fast and reliable neural network-based capability models.