Limitations in Quantum Computing from Resource Constraints

Fault-tolerant schemes can use error correction to make a quantum computation arbitrarily accurate, provided that errors per physical component are smaller than a certain threshold and independent of the computer size. However, in current experiments, physical-resource limitations such as energy, volume, or available bandwidth induce error rates that typically grow as the computer grows. We analyse how error correction performs under such constraints and show that the amount of error correction can be optimized, leading to a maximum attainable computational accuracy. We find this maximum for generic situations where noise is scale dependent. By inverting the logic, we provide experimenters with a tool for finding the minimum resources required to run an algorithm with a given computational accuracy. When combined with a full-stack quantum computing model, this provides the basis for energetic estimates of future large-scale quantum computers.

Popular Summary

There is intense academic and industrial interest in building large-scale quantum computers to solve problems that traditional computers cannot solve. Unfortunately, quantum computers are very sensitive to errors and require clever error-correction schemes, known as fault-tolerant quantum computing, to make the effect of errors on the calculation arbitrarily small. However, there is a price to pay: the more the scheme reduces the effect of errors, the more physical resources (such as the size of the quantum computer and the electrical power needed to drive it) it requires. We investigate how quantum computers behave when those resources are limited. We find that the effect of errors cannot always be removed with fault-tolerant quantum computing, because too much error correction can actually introduce more errors than it removes. This puts a limit on the accuracy of quantum computers tackling large-scale problems. We show how the available resources should be used to maximize this accuracy.

More precisely, fault-tolerant quantum computing relies on the assumption that the noise per gate remains constant as the quantum computer grows in scale. Unfortunately, this is untrue in many quantum devices today, often as a consequence of limited physical resources. We show why one cannot correct all errors for such scale-dependent noise and provide tools to optimize the error correction with limited resources.

The tools we provide will have a strong impact on ensuring sustainable resource utilization for quantum computing. This will require experimenters to minimize both the magnitude and the scale dependence of their noise, while theoreticians should develop fault-tolerant schemes for scale-dependent noise. Our analysis can be further extended to optimize resource requirements for accurate calculations in a full-stack quantum computing platform.

Figure 1

How resource constraints can lead to increased computational errors. Each gate operation on a physical qubit (blob) requires a certain amount of physical resource (fence) for good control. If the number of physical qubits increases as the computer grows, without a proportionate increase in control resource, errors will increase.

Figure 2

The accuracy of a quantum computation can be increased by a FTQC scheme that makes use of concatenation and recursive simulation. Circuits are designed to be hierarchical, with high-level gate components built from lower-level components in a self-similar manner.

Figure 3

The black dotted curves are a schematic of the conventional situation, where the physical error probability $\eta$ is independent of the scale—the concatenation level $k$— of the computer. The red solid curves are a schematic of the consideration in this work, where $\eta$ grows with $k$ (each red curve is for a different value of $p^{(0)}\equiv \eta$). If $\eta$ is $k$ independent, standard FTQC analysis says that the error per logical gate $p^{(k)}$ can be brought as close to $0$ as desired by increasing $k$, provided that one starts below the threshold (solid horizontal line) at $k=0$. If $\eta$ depends on $k$, even if one starts below the threshold, $p^{(k)}$ eventually turns around for large enough $k$. $p^{(k)}$ cannot reach $0$; there is a maximum concatenation level and a further increase in $k$ only increases the logical error. All examples in this work have at most one minimum in each red curve but, in general, there can be multiple minima.

Figure 4

(a) An example of how $p^{(k)}$ varies as the concatenation level $k$ increases, for the affine model with $c=0$ (lightest color), $0.5,1,\dots ,10$ (darkest color), $B={10}^4$, and ${\eta }^{(0)}=5\times {10}^{-6}$, for which $B{\eta }^{(0)}=0.05$, far below the threshold for $c=0$. All curves, apart from that for $c=0$, turn around for large enough $k$. (b) The maximum $k$ value, $k_{max}$, such that $p^{(k+1)}<p^{(k)}$, with $p^{(0)}\equiv {\eta }^{(0)}$, the unencoded error probability, for different values of $B{\eta }^{(0)}<1$ and $c\in \{0,0.1,0.2,\dots ,10\}$. In every case, $k_{max}$ eventually falls to zero for large enough $c$, i.e., it is better to have no encoding.

Figure 5

(a) A qubit-in-waveguide schematic: the photon pulse for gate operations. (b) $k_{\max }$ as a function of number of photons per logical gate ${\overline{n}}_L={\overline{n}}_{\mathrm{tot}}/R^2$ (see text). (c) The lowest possible error per logical gate $p^{(k_{\max })}$ as a function of ${\overline{n}}_L={\overline{n}}_{\mathrm{tot}}/R^2$, for Shor’s factoring algorithm. The horizontal red dashed lines correspond to the different target ($p_{\mathrm{err}}$) values for different $R$ values.