What determines the ultimate precision of a quantum computer?

TL;DR

This paper investigates physical limitations on the ultimate precision of logical qubits in quantum error correction, identifying silent stabilizer failures as a key factor that caps logical qubit accuracy regardless of code size.

Contribution

It reveals a physical mechanism, silent stabilizer failure, that limits logical qubit precision beyond standard QEC theoretical predictions.

Findings

Silent stabilizer failures can cause logical qubit failure independently of code size.

A single local error can compromise the logical qubit, setting a fundamental precision limit.

The maximum number of operations is constrained by the precision limit, affecting quantum circuit depth.

Abstract

A quantum error correction (QEC) code uses $N_{\rm c}$ quantum bits to construct one "logical" quantum bits of better quality than the original "physical" ones. QEC theory predicts that the failure probability $p_L$ of logical qubits decreases exponentially with $N_{\rm c}$ provided the failure probability $p$ of the physical qubit is below a certain threshold $p<p_{\rm th}$. In particular QEC theorems imply that the logical qubits can be made arbitrarily precise by simply increasing $N_{\rm c}$. In this letter, we search for physical mechanisms that lie outside of the hypothesis of QEC theorems and set a limit $\eta_{\rm L}$ to the precision of the logical qubits (irrespectively of $N_{\rm c}$). $\eta_{\rm L}$ directly controls the maximum number of operations $\propto 1/\eta_{\rm L}^2$ that can be performed before the logical quantum state gets randomized, hence the depth of the quantum circuits that can be considered. We identify a type of error - silent stabilizer failure - as a mechanism responsible for finite $\eta_{\rm L}$ and discuss its possible causes. Using the example of the topological surface code, we show that a single local event can provoke the failure of the logical qubit, irrespectively of $N_c$.

Equations

$$|{\Psi }_L⟩=\alpha |0_L⟩+\beta |1_L⟩.$$

$$|0_L⟩=|00\dots 00⟩,|1_L⟩=|11\dots 11⟩.$$

$$R_i=\left(\begin{array}{cc}{c}_i& -s_i\\ s_i& c_i\end{array}\right)$$

$$|{\Psi }_1⟩=(\alpha c_1{c}_2{c}_3-\beta s_1{s}_2{s}_3)|000⟩$$

$$p_{\#}\sim N_{\#}{N}_L\left[(p/p_{\mathrm{th}}{)}^{\sqrt{N_c}/2}+p_s{N}_c\right]$$

Full text

A quantum computer is an analog machineLandauer (1994); Dyakonov (2013). By this statement, we mean that its internal state is set by complex numbers that vary *continuously *. A direct consequence of being analogue is that a quantum operation can only be performed with a finite precision $\eta$. As one performs more operations, the overall precision of the machine deteriorates and eventually the quantum state gets randomized. Hence finite precision implies that a finite maximum number $N_{\#}\sim 1/\eta^{2}$ of meaningful operations can be performed. This number - tagged the maximum ”depth” of a quantum circuit - is of prime importance to quantum computing. Quantum algorithms generically require that the number of operations increases with the size of the problem (number of qubits) so that $\eta$ also determines the maximum size of a useful machine. In short, the precision $\eta$ is the prime indicator of the computing power of a quantum computer. Typical quantum circuits implemented so far report depths values of a few tens for two qubits circuits O’Malley et al. (2016) down to a few units for circuits with a few qubits Peruzzo et al. (2014); Kandala et al. (2017) or more than ten qubits Otterbach et al. (2017). An increasing effort is devoted to studying the advantages that could be harnessed from small depth quantum computers Moll et al. (2017); Neill et al. (2017); Preskill (2018). However, the long term goal of quantum computing still remains achieving an exponential acceleration with respect to a classical computer, which implies large depths. For instance, the study of Reiher et al. (2017) - devoted to the application of quantum algorithms to assist quantum chemistry calculations - estimates that $N_{\#}\sim 10^{15}$ operations are needed to achieve chemical precision in a $50$ levels calculation ($50$ electronic levels being roughly the maximum size that can be calculated with brute force classical computing).

Quantum Error Correction (QEC) proposes a solution to the precision problem by building ”logical qubits” out of several ($N_{c}$) physical qubits. The logical qubits are more robust and more precise than the original qubits from which they are built. A crucial result of QEC theory is that the precision $\eta_{\rm L}$ of the logical qubit improves exponentially with $N_{c}$. In other words, QEC allows one to build logical qubits of unlimited precision (hence unlimited depth $N_{\#}$) at an affordable cost in terms of hardware. This is a very strong statement. A natural question, that we will try to address in this letter is therefore what ultimately limits the precision $\eta_{\rm L}$ that can be reached by the logical qubits. Can the precision $\eta_{\rm L}$ improve without limits? Within QEC theorems, the answer is yes. However these theorems rely on certain hypothesis that some physical mechanisms, such as correlated or leakage errors, do not fulfill. In this letter, we revisit the QEC construction and seek mechanisms that would set a limit to $\eta_{\rm L}$ irrespectively of the value of $N_{c}$. We find a class of errors - silent stabilizer failure - that provides a generic mechanism for limiting $\eta_{\rm L}$ to a finite value.

QEC stabilizer theory in a nutshell. While some of our statements are general, we will illustrate our arguments with two QEC codes: the surface code Fowler et al. (2012) (the most promising architecture at the moment) and the repetition code Fowler (2013) (for pedagogical reasons). These two codes belong to the general category of ”stabilizer” codes Shor (1995); Steane (1996); Laflamme et al. (1996); Shor (1996); DiVincenzo and Shor (1996); Plenio et al. (1997); Aharonov and Ben-Or (1997); Knill et al. (1998); Kitaev (1997); Fowler (2012). QEC uses robust states $|0_{L}\rangle$ (logical zero) and $|1_{L}\rangle$ (logical one) to spread out the information of a logical qubit onto $N_{c}$ physical qubits. A logical state $|\Psi_{L}\rangle$ of the logical qubit is encoded as,

[TABLE]

The states $|0_{L}\rangle$ and $|1_{L}\rangle$ are given implicitely by a set of $N_{c}-1$ observables $g_{\alpha}$ known as the stabilizers. The $g_{\alpha}$ are product of Pauli matrices $X_{i}$, $Y_{i}$ and $Z_{i}$ that act on qubit $i$. They commute with each others, have $\pm 1$ eigenvalues, and verify: $g_{\alpha}|\Psi_{L}\rangle=+1|\Psi_{L}\rangle$. Figure 1 shows the stabilizers of the repetition and surface code. QEC consists in repeatidly measuring all the different stabilizers in order to maintain the state inside the logical subspace. The set of observed values is called the syndrome. The presence of one or more $-1$ in the syndrome indicates the presence of errors which must be tracked, see for instance Nielsen and Chuang (2011) for details. In the repetition code (see Fig.1a), the logical states $|0_{L}\rangle$ and $|1_{L}\rangle$ are simply given by

[TABLE]

and the stabilizers $g_{i}=Z_{i}Z_{i+1}$ check that one qubit and the next are in the same state. If an error $|\Psi_{L}\rangle\rightarrow X_{j}|\Psi_{L}\rangle$ happens, then the syndromes of $g_{j-1}$ and $g_{j}$ change from $+1$ to $-1$. The error is detected and can be corrected by applying $X_{j}$. The repetition code obviously cannot correct $Z_{i}$ type of errors but its cousin where the ”Z” stabilizers are replaced by ”X” stabilizers ($g_{i}=X_{i}X_{i+1}$) can. Figuratively, the surface code can be seen as the product of these two repetition codes in order to correct for all kind of errors. In the discrete error model, each qubit has a probability $p$ to get an error per clock cycle, and the errors are uncorrelated. The logical qubit remains infinitely precise except when more than half of the data qubits are corrupted. The probability $p_{L}$ for logical failure $p_{L}\sim(p/p_{\rm th})^{N_{c}/2}$ (repetition code) and $p_{L}\sim(p/p_{\rm th})^{\sqrt{N_{c}}/2}$ (surface code, $p_{\rm th}\approx 0.01$) decreases exponentially with $N_{c}$ provided $p$ is smaller than the threshold $p_{\rm th}$.

Precision errors for the repetition code. Let us now study how QEC handles precision (also known as coherent) errors. Precision errors include small over/under rotation in the application of a gate, the presence of small unknown terms in the qubit Hamiltonian matrix, the effect of small variation of the energy splitting of a qubit, errors in the direction of a measurement and many other sources. Precision errors reflect the fact that handling a qubit can only be done with a finite precision. We model this imprecision by applying a rotation $R_{i}$ of small angle $\theta_{i}$ on each of the qubits at each clock cycle:

[TABLE]

with $c_{i}=\cos\theta_{i}/2$ and $s_{i}=\sin\theta_{i}/2$. The typical value of each angle is parametrized by a small angle $\eta$ to which we refer as the ”precision” of the qubit: $\theta_{i}\sim\eta$.

We suppose that we are initially in $|\Psi_{L}\rangle$ and study the effect of one round of precision errors. We arrive at $|\Psi_{1}\rangle$ (assuming for concision the repetition code with $N_{c}=3$),

[TABLE]

We now apply the QEC protocal and measure the stabilizers $g_{1}$ and $g_{2}$. Several results can occur. With a large probability $P\equiv|\alpha c_{1}c_{2}c_{3}-\beta s_{1}s_{2}s_{3}|^{2}+|\alpha s_{1}s_{2}s_{3}+\beta c_{1}c_{2}c_{3}|^{2}\sim 1$, we obtain no error (syndrome $+1,+1$) and the measurement projects the state directly back to the logical state. We arrive at $|\Psi_{2}\rangle=\left[(\alpha c_{1}c_{2}c_{3}-\beta s_{1}s_{2}s_{3})|000\rangle\right.+\left.(\alpha s_{1}s_{2}s_{3}+\beta c_{1}c_{2}c_{3})|111\rangle\right]/\sqrt{P}$. Since $\eta\ll 1$, we find that $|\Psi_{2}\rangle\approx(\alpha-\beta\eta^{3}/8)|000\rangle+(\beta+\alpha\eta^{3}/8)|111\rangle$, i.e. instead of the original precision $\eta$ on the physical qubit, the logical one has a much better precision $\eta_{L}\sim\eta^{3}$. A second possible outcome of the stabilizer measurement is to observe a faulty syndrom. For instance, with probability $P^{\prime}\equiv|\alpha s_{1}c_{2}c_{3}+\beta c_{1}s_{2}s_{3}|^{2}+|\alpha c_{1}s_{2}s_{3}-\beta s_{1}c_{2}c_{3}|^{2}\sim\eta^{2}$ one gets the syndrom $(-1,+1)$ and $|\Psi_{2^{\prime}}\rangle\sim(\alpha+\beta\eta/2)|100\rangle+(\beta+\alpha\eta/2)|011\rangle$ which after applying $X_{1}$ returns to the code: $|\Psi_{3^{\prime}}\rangle\sim(\alpha+\beta\eta/2)|000\rangle+(\beta+\alpha\eta/2)|111\rangle$. In this case, the error on the logical qubit is of the same order $\eta_{L}\sim\eta$ as on the original physical qubits. However, since this occurance is rare $P^{\prime}\sim\eta^{2}$, in average the errors accumulate much more slowly. Generalizing to arbitrary $N_{c}$, we find that the logical precision after the measurement is $\eta_{L}\sim\eta^{N_{c}-2n}$ when $n$ errors are detected, which happens with probability $\eta^{2n}$. In particular, complete logical failure $\eta_{L}\sim 1$ happens with probability $\eta^{N_{c}}$.

Several important conclusions can be drawn from the above analysis. (1) First and above, the main role of the measurement of the stabilizers is not the actual value of the syndroms but the projection that is associated with the measurement. Even if one always find all syndroms to be $+1$ (i.e. ”no error”), the role of the projection is crucial to reduce the loss of precision to $\eta_{L}\sim\eta^{N_{c}}\ll\eta$. (2) It can be tempting to identify the parameter $p$ of the discrete error model with $p\sim\eta^{2}$ Terhal (2015); Nielsen and Chuang (2011). Indeed within the precision error model, the probability to get one error is $p\sim\eta^{2}$ and the probability for total failure of the logical qubit leads to the correct scaling $p_{L}\propto p^{N_{c}/2}$. However there is a crucial difference between the two error models: when there is a number $n$ of errors close to the maximum $N_{c}/2$ that the code can correct, the discrete error model assumes a perfect restoration of the logical state while in the precision error model, $\eta_{L}$ increases as fast as without error correction, i.e. dangerously fast. (3) This difference - and the fact that precision errors are always present in real life - shed some light on the notion of the ”depth” of a circuit (and the associated concept of computing volume Moll et al. (2017)), i.e. how many operations one can perform on a qubit before failure. In the discrete error model, the depth is independent of the type of calculation that one wants to perform ($\sim 1/p_{L}$). However, in actual devices, it will strongly depend on the effective precision needed at the end of the calculation. For instance the quantum fourrier transform algorithm Shor (1994) constructs an interference pattern where a very large number of unwanted states interfere destructively while the desired solution interfere constructively. Achieving such an interference requires a very high accuracy on the relative phases between the qubits. In evaluating a computing capability, one should therefore assess what is the needed accuracy at the end of the calculation (when the data qubits are measured) and this accuracy strongly depends on the algorithm. (4) The community usually describes the accuracy with which a gate is performed in terms of $p$, not $\eta$. This implies for instance that a one qubit gate performed with $99\%$ fidelity corresponds to a precision $\eta\approx 0.1$, i.e. 6 degrees. (5) If one slightly complicates the above picture and applies the precision errors also on the ancilla qubits (i.e. in between all gates of the circuit shown in Fig.1d and also in between the measurements of two stabilizers), the syndrom analysis becomes more complex as one can gets wrong values of the syndroms; one must perform several measurements of the stablilizers before being able to decide on the presence of error. However, in contrast to what we wrote in an earlier version of this manuscript Waintal (2017), the procedure still works and produces the same increase of logical precision as described above.

Silent stabilizer failure error. Hence, precision is maintained by the constant measurement of the stabilizers. Let us now examine what happens if the measurement of *one single * stabilizer does not occur for a few clock cycles. We further suppose that this failure is ”silent”, i.e. not revealed by the measurement of the corresponding ancilla. We stress that we define the stabilizer failure as the absence of measurement which is drastically different from a measurement that gives a wrong result. We will discuss below possible mechanisms that can produce such a silent stabilizer failure, but we can already note that it must happen with a finite probability $p_{s}$ per stabilizer since it is a local error that affects a small part of the circuit - there is always a finite probability that a small part of the circuit does not function properly. The probability to get at least one such stabilizer failure on the logical qubit is thus $1-(1-p_{s})^{N_{c}-1}\sim N_{c}p_{s}$ and increases linearly with the size of the code. We argue that silent stabilizer failure errors generically leads to a failure of the logical qubit hence that that there exist a maximum value of $N_{c}$ above which increasing the size of the code deteriorates the logical qubit.

During the stabilizer failure, the size of the ”logical” Hilbert space increases by a factor two since there is one less stabilizer measured. In other word, the stabilizer failure temporarily creates another ”logical” qubit that we will call (temporary) silent qubit. By construction the silent qubit is insensitive to the measurement of the $N_{c}-2$ functional stabilizers. The main question to answer is therefore will the silent qubit become entangled (hence eventually corrupt) with the logical qubit. The logical failure will happen from a combination of two mechanisms: imprecision errors as described above and another ingredient from QEC theory - fault tolerant operations - that we now introduce. Indeed so far, we have shown that QEC is capable of maintaining a certain accuracy of the logical qubit despite the presence of, say, precision errors. ”Fault tolerant operations” adds the mean to manipulate the logical qubits (for instance perform a Control-Not operation between two logical qubits) within the same accuracy. By construction, these operations need to cross the large distance between the logical states. Without them, the logical qubits are essentially useless.

To be specific, we now focus on the surface code Fowler et al. (2012). Fig.2 illustrates logical qubits that are built by making pairs of holes in the surface code. A hole corresponds to a bunch of stabilizers and data qubits that are (momentarily) diregarded. The role of $N_{c}$ in the repetition code is now held by the ”distance of the code”, i.e the number of qubits that separates the two holes (or the number of qubits needed to make a loop around a hole, whichever of the two is the smallest). The logical X operator of qubit A is given by $X_{\rm A}=\prod_{i\in\mathcal{A}}X_{i}$ where the data qubit $i$ belongs to the data set $\mathcal{A}$ inside the pink dashed line that links the two holes of qubit A, see Fig.2. A similar definition holds for the $Z_{A}$ operator (the set loops around the upper hole of qubit A) and for qubit B (the role of X and Z is exchanged with respect to A). Now we suppose the silent stabilizer failure as drawn on the figure by a small hole. This hole corresponds to an unwanted extra logical ”silent” qubit. The logical Z operator $Z_{\rm S}=\prod_{i\in\mathcal{C}}Z_{i}$ of the silent qubit is the product of the $Z_{i}$ for the data set $\mathcal{C}$ of qubits enclosed in the corresponding black dashed line on Fig.2 while its logical X operator $X_{\rm S}=\prod_{i\in\mathcal{C^{\prime}}}X_{i}$ corresponds to the qubits $\mathcal{C^{\prime}}$ enclosed by the pink dashed line. $X_{S}$ corresponds in fact to the missing stabilizer so that initially, the silent qubit is in a state $|+\rangle=(|0\rangle+|1\rangle)/2$. By construction, the distance (number of data qubit) of $X_{S}$ is $4$ while the distance of $Z_{S}$ is $1$ or higher ($4$ in the figure). In the case considered here, both distances are small so that precision errors will quickly build up and the silent qubit ends up in an arbitrary state on the Bloch sphere, irrespectively of the distance of the code itself. Logical operations provide an efficient mechanism that entangle our -now random - silent qubit with the rest of the code, hence jeopardizing logical qubits. In Fig.2, a Control-Not gate between A and B is performed by ”braiding” Fowler et al. (2012), i.e. moving the lower hole of qubit A in a loop around the upper hole of B as indicated by the blue arrow in Fig.2. Upon braiding Qubit A with Qubit B, one also braids A with the silent qubit which creates entanglement at the logical level between S and A. This is fatal to qubit A. We see that it is sufficient that a single stabilizer failure occurs for the duration of one logical operation to produce an irreversible logical failure, irrespectively of $N_{c}$.

Examples of physical mechanisms for silent stabilizer failure. Let us focus on two important physical qubits implementations, the superconducting transmon Koch et al. (2007) and the semi-conducting singlet-triplet double quantum dot qubitLoss and DiVincenzo (1998). In both instances, the qubits are operated using carefully shaped microwave pulses whose frequency are resonant with a given transition. Suppose now that a classical two level system (for instance a trapped charge that can choose between two positions), sits close to an ancilla qubit. When this two level system changes its position (which may happen on any time scale from sub $\mu s$ to hours), it produces a change of the energy of the ancilla. As a result, the microwave pulses are no longer resonant and the pulses which are supposed to perform the Control-Not gates of Fig.1d do, in fact, nothing to the qubit state. When the ancilla is measured, it does not perform the measurement of the stabilizer. Note that in the language of QEC, this error (correlated failure of four Control-Not gates for several cycles) is known as a correlated error. However, it is caused by a single physical error, the ”correlation” only arises from the mathematical modeling. A second mechanism involves the so called ”leakage” errors, i.e. errors that leave the code outside of its computational space. For instance, the superconducting transmon is built out of a slightly anharmonic oscillator. When one applies a $X$ gate on a $|0\rangle$ state, there is a small (measured in the $10^{-5}$ range Chen et al. (2016)) probability that the qubit ends up not in $|1\rangle$ but in a state $|2\rangle$ of higher energy where the qubit can stay for some clock cycles and cannot be operated. Singlet-triplet qubits can work in regimes where the ground state does not belong to the computational state, so that a simple relaxation can create a leakage error.

The error-by-error approach. The strength of QEC arises from the fact that the failure of a logical qubit requires the failure of many data qubits, hence the exponential precision usually advocated. We have argued that this strength is also an important weakness since the data qubits are associated with as many stabilizers and the failure of a single stabilizer is sufficient to provoke the failure of the code. While the generic class of (silent) stabilizer failure is intrinsically fatal to the code, particular instances of this class may be faught by modifying the code Aliferis and Terhal (2007); Silva et al. (2008); Stace et al. (2009); Ghosh et al. (2013); Fowler (2013); Mehl et al. (2015); Fowler and Martinis (2014); Hutter and Loss (2014) in order to monitor the corresponding error. After such as fix, one is left with a more complex code (with more operations and/or ancillas) hence a degraded threshold. On the other hand a source of stabilizer failure has been removed hence the corresponding probability $p_{s}$ gets smaller, yet always finite. $p_{s}$ is now dominated by another error that must be identified and eventually mitigated in an error-by-error manner. This process is very different from simply scaling up the surface code to a larger surface. Note that we have emphasized the silent stabilizer failure error class since it is always fatal hence easier to discuss. A stabilizer failure that is non-silent is not necessarily fatal but might be an important hazard in practice. First, it effectively divides the distance of the code by 2 (in average) hence the associated loss in precision due to precision errors. Second, the presence of the uncontroled logical qubit puts strong restrictions on the braiding operations that can be performed, very possibly blocking the entire calculation. Let us end this discussion with an example of those mitigating solutions that may be attempted to detect a silent stabilizer failure. One could, for instance, modify the stabilizer measurement by preparing the ancilla in a state which is not always $|0\rangle$ but alternates between $|0\rangle$ and $|1\rangle$, hence alternating syndroms $+1$,$-1$. Such a scheme might be able to detect a simple ancilla leakage, but does not work against the fluctuator discussed in the preceeding section. One could generate the alternating syndrom by adding $X$ operators on some of the data qubits during the syndrom measurement protocal (at the cost of adding extra operations hence noise in the process). Mitigating methods like that may work for detecting the stabilizer failure. If such a syndrom failure can be detected, additional steps much be taken to fix it since the code should not stay with the associated extra logical (formerly silent) qubit. These steps require either additional redondant hardware (extra ancillas) or a restructuration of the code (turning data qubits into ancilla for instance). One could imagine rarer errors (such as a direct coupling between ancillas or an indirect one mediated by a microwave pulse) that would not be detected by the above scheme and that would require additional modifications of the code to be detected. In short, errors that affect the measurement of the stabilizers must be faught one by one in an iterative process of identification and code modification. This is in sharp contrast with the more standard type of errors that are handled by scaling.

*To summarize, * the global probability for a quantum calculation to fail in the plain surface code reads to leading order,

[TABLE]

where $N_{L}$ is the number of logical qubits involved in the calculation. Following the example of the middle size quantum computer of $N_{L}=2\times 50$ logical qubits considered in Reiher et al. (2017) ($N_{\#}>10^{15}$, $N_{c}>1000$), the probability for fatal errors must be extremely low $p_{s}<10^{-20}$ for a calculation to be possible. Actual values of $p_{s}$ are not known, since they are currently hidden by the larger rate $p$ of correctable errors, but based on the mechanisms outline above $p_{s}\sim 10^{-5}$ or perhaps higher is plausible. Lowering the rate $p_{s}$ cannot be done by simply scaling up $N_{c}$. It implies a tedious error-by-error approach where very rare hidden errors must first be identified and then the QEC protocol must be complexified (at the cost of increasing $p/p_{\rm th}$) for these errors to become correctable. The literature contains many such proposals for various sort of errors Aliferis and Terhal (2007); Silva et al. (2008); Stace et al. (2009); Ghosh et al. (2013); Fowler (2013); Mehl et al. (2015); Fowler and Martinis (2014); Hutter and Loss (2014). However, for any given architecture there will always be a mechanism that set the ultimate limit that can be achieved. This ultimate limit is the ”computing power horizon” of a given technology. At a time where many different quantum computing platforms are developped by many academic and even industrial groups, we advocate that identifying the mechanisms responsible for the (present) horizons of these technologies is a key strategic element.

Acknowledgment

Warm thanks to M. Sanquer who pointed Ref.Dyakonov (2013) to us which triggered the present study. The hospitality of the National University of Singapore where this work was initiated during the French-Singapore QuESTs symposium is also acknowledged. We thank A. Fowler, T. Meunier, JM Gerard, N. Mahrour, M. Houzet, P. Bertet, N. Roch and M. Mirrahimi for useful discussions or correspondance.