Efficient quantum error correction of dephasing induced by a common fluctuator

TL;DR

This paper introduces a new family of quantum error-correcting codes specifically designed to efficiently correct dephasing caused by a common fluctuator, significantly reducing overhead and suitable for near-term quantum devices.

Contribution

The authors develop special-purpose quantum error-correcting codes that exponentially reduce overhead for correcting dephasing from a common fluctuator, tailored for small-scale quantum systems.

Findings

Codes correct to order t^{O(2^n)} for n qubits

Smallest code encodes 1 logical qubit into 2 physical qubits

Codes are robust to model imperfections and improve error suppression

Abstract

Quantum error correction is expected to be essential in large-scale quantum technologies. However, the substantial overhead of qubits it requires is thought to greatly limit its utility in smaller, near-term devices. Here we introduce a new family of special-purpose quantum error-correcting codes that offer an exponential reduction in overhead compared to the usual repetition code. They are tailored for a common and important source of decoherence in current experiments, whereby a register of qubits is subject to phase noise through coupling to a common fluctuator, such as a resonator or a spin defect. The smallest instance encodes one logical qubit into two physical qubits, and corrects decoherence to leading-order using a constant number of one- and two-qubit operations. More generally, while the repetition code on $n$ qubits corrects errors to order $t^{O(n)}$, with $t$ the time between recoveries, our codes correct to order $t^{O(2^n)}$. Moreover, they are robust to model imperfections in small- and intermediate-scale devices, where they already provide substantial gains in error suppression. As a result, these hardware-efficient codes open a potential avenue for useful quantum error correction in near-term, pre-fault tolerant devices.

Equations

$$H=H_f^0+\frac{1}{2}\sum _{j=1}^n{\omega }_j{Z}_j+H_f^{\text{int}}\otimes \sum _{j=1}^n{g}_j{Z}_j$$

$$\tilde{H}=\sum _{\ell }{\lambda }_{\ell }|\ell ⟩{⟨\ell |}_f\otimes H_E,$$

$$n=\lceil 1+{\log }_2(q+1)\rceil$$

$$⟨0_{\text{textsc}l}|H_E^m|0_{\text{textsc}l}⟩=⟨1_{\text{textsc}l}|H_E^m|1_{\text{textsc}l}⟩$$

$$⟨0_{\text{textsc}l}|H_E^m|1_{\text{textsc}l}⟩=0$$

$$|0_{\text{textsc}l}⟩=\sum _{j=0}^{2^n-1}{r}_j{e}^{i{\theta }_j}|j⟩|1_{\text{textsc}l}⟩=\sum _{j=0}^{2^n-1}{r}_{(2^n-1-j)}{e}^{i{\varphi }_j}|j⟩,$$

$$⟨0_{\text{textsc}l}|H_E^m|0_{\text{textsc}l}⟩=-⟨1_{\text{textsc}l}|H_E^m|1_{\text{textsc}l}⟩=\vec{z}\cdot {\vec{v}}_m,$$

$$(r_j,r_{(2^n-1-j)})=\{\begin{array}{ll}(0,\sqrt{z_j}),& \text{if }{z}_j\ge 0\\ (\sqrt{-z_j},0),& \text{if }{z}_j<0.\end{array}$$

$$r_0=c\sqrt{g_1-g_2}{r}_2=c\sqrt{g_1+g_2},$$

$$|0_{\text{textsc}l}⟩=|{\chi }_0⟩|0⟩|1_{\text{textsc}l}⟩=|{\chi }_1⟩|1⟩$$

$$\begin{split}{|{\chi_{0}}\rangle}&=c\Big{(}\sqrt{|g_{1}-g_{2}|}\,e^{i\theta_{0}}\,{|{0}\rangle}+\sqrt{|g_{1}+g_{2}|}\,e^{i\theta_{2}}\,{|{1}\rangle}\Big{)}\\ {|{\chi_{1}}\rangle}&=c\Big{(}\sqrt{|g_{1}+g_{2}|}\,e^{i\phi_{1}}\,{|{0}\rangle}+\sqrt{|g_{1}-g_{2}|}\,e^{i\phi_{3}}\,{|{1}\rangle}\Big{)},\end{split}$$

$$\begin{array}{rl}{H}_E|0_{\text{textsc}l}⟩& \propto |{\chi }_1⟩|0⟩=:|0_{\text{textsc}e}⟩\\ H_E|1_{\text{textsc}l}⟩& \propto |{\chi }_0⟩|1⟩=:|1_{\text{textsc}e}⟩.\end{array}$$

$$S=P_{\text{textsc}l}-P_{\text{textsc}e}=U_z\otimes Z_2$$

Full text

Decoherence, the uncontrolled decay of coherence in open quantum systems, is a central obstacle to developing coherent quantum technologies such as quantum sensors, networks, and computers. This obstacle is compounded by the destructive nature of quantum measurement: straightforward attempts to identify—and ultimately reverse—decoherence destroy the quantum coherence they seek to protect. Quantum error correction (QEC) is a technique for taming decoherence which sidesteps this issue. It encodes lower-dimensional quantum states into a higher-dimensional quantum system such that decoherence can be detected and approximately reversed without collapsing the encoded state. Specifically, the most common approach encodes $k$ logical qubits into an $n$-qubit register ($k<n$) whose Hilbert space $\mathcal{H}$ is decomposed into orthogonal subspaces $\mathcal{C}_{0},\mathcal{C}_{1},\mathcal{C}_{2},\dots$ of dimension $2^{k}$ 111In general, there could also be a “remainder” subspace $\mathcal{C}_{\textsc{r}}$ of arbitrary dimension so that $\mathcal{H}=\left(\bigoplus_{i}\mathcal{C}_{i}\right)\oplus\mathcal{C}_{\textsc{r}}$. These subspaces are chosen by specifying operators $E_{1},E_{2},\dots$ and demanding that the logical states, which reside in $\mathcal{C}_{0}$, be mapped to $\mathcal{C}_{i}$ by $E_{i}$ without distortion 222While it is possible for multiple $E_{i}$’s to have the same effect on the logical states, thus reducing the number of subspaces required for QEC, we will not deal with such degenerate codes here.. By performing a partial measurement that reveals only which subspace contains the state, and feeding back appropriately, one can reverse the occurrence of any $E_{i}$—and more generally, any error in $\mathcal{E}=\text{span}\{I,E_{1},E_{2},\dots\}.$ The conventional strategy is to pick $E_{i}$’s so that $\mathcal{E}$ encompasses a broad family of operators on $\mathcal{H}$. Using Pauli operators of weight up to $w$, for instance, produces a QEC code that corrects arbitrary errors on $w$ qubits. This is a powerful approach, especially in large devices ($n\gg 1$), since it can reverse decoherence with little regard to its physical origins Nielsen and Chuang (2010); Lidar and Brun (2013). For smaller devices, however, casting such a wide net requires an overhead of qubits ($n-k$) that is often prohibitive for near-term applications. A more economical strategy for small- and intermediate-scale devices is instead to use a QEC code with $\mathcal{E}$ tailored to include only the dominant, well-characterized decoherence modes. However, while this strategy is well-known (see Nielsen and Chuang (2010) §10.6.4), few explicit such codes have been discovered; see, e.g., Refs. Leung et al. (1997); Robertson et al. (2017); Layden et al. (2019).

In order to systematically find noise-tailored QEC codes, here we focus on dephasing, since it is the dominant type of decoherence in various experiments. In particular, we consider the common scenario where dephasing in a register of qubits arises primarily due to eigenstate-preserving coupling of each qubit to a common fluctuator, which in turn exchanges energy with an external environment. That is, we consider a Hamiltonian

[TABLE]

where $[H_{f}^{0},H_{f}^{\text{int}}]=0$, and a fluctuator that jumps incoherently between energy eigenstates $\{{|{\ell}\rangle}_{f}\}$ (reflected by a dissipative term in the overall master equation). Moving to the interaction picture, the Hamiltonian (1) becomes

[TABLE]

where $H_{f}^{\text{int}}=\sum_{\ell}\lambda_{\ell}{|{\ell}\rangle}\!{\langle{\ell}|}_{f}$ and $H_{E}:=\sum_{j=1}^{n}g_{j}Z_{j}$. When the fluctuator is in state ${|{\ell}\rangle}_{f}$, qubit $j$ has an effective Hamiltonian $\lambda_{\ell}\,g_{j}Z_{j}$ in the rotating frame. Jumps of the fluctuator therefore induce spatially-correlated random telegraph noise in the register, which causes dephasing Machlup (1954); Neuenhahn et al. (2009). This model, which we call common-fluctuator dephasing (CFD), often describes the main decoherence mechanism in nuclear spins near spin defects (e.g., Nitrogen-Vacancy centers in diamond Chen et al. (2018)) or quantum dots, and can also be significant in superconducting qubits dispersively coupled to a common resonator with non-zero effective temperature cou ; Maurer et al. (2012); Shim et al. (2013); Zaiser et al. (2016); Chen et al. (2018); Bertet et al. (2005a, b); Gambetta et al. (2006); Majer et al. (2007); Clerk and Utami (2007); Sears et al. (2012); Yan et al. (2016); Yeh et al. (2017); Yan et al. (2018); Wang et al. (2019). Often the register is read out and/or initialized via the fluctuator, imposing a lower limit on the desirable coupling strengths $g_{j}$, and making CFD a significant decoherence mode. Note that CFD does not generally produce a decoherence-free subspace (DFS).

The standard QEC approach to correct dephasing uses $E_{i}$’s comprising Pauli $Z$ operators on at most $w$ qubits (and $I$ on the rest). There are $\sum_{m=0}^{w}\binom{n}{m}$ such matrices; a simple counting argument (the quantum Hamming bound applied to phase noise) therefore suggests that $n\geq 2w+1$ physical qubits are required to protect $k=1$ logical qubit from arbitrary phase errors of weight $\leq w$ Nielsen and Chuang (2010). Indeed, the repetition code saturates this bound: the smallest instance uses $n=3$ for $w=1$, has logical states ${|{0_{\textsc{l}}}\rangle}={|{+\!+\!+}\rangle}$ and ${|{1_{\textsc{l}}}\rangle}={|{-\!-\!-}\rangle}$ where ${|{\pm}\rangle}:=\frac{1}{\sqrt{2}}({|{0}\rangle}\pm{|{1}\rangle})$, and corrects for $\mathcal{E}=\text{span}\{I,Z_{1},Z_{2},Z_{3}\}$. It can correct CFD as follows: In any run of the experiment, the register evolves over time $t$ as $U(\theta)=e^{-i\theta H_{E}}$ for some random variable $\theta\in[t\lambda_{\text{min}},t\lambda_{\text{max}}]$ that depends on the fluctuator’s trajectory. For short $t$ (understood in units of $1/\max_{j\ell}|g_{j}\lambda_{\ell}|$, and often reducible through dynamical decoupling Viola and Lloyd (1998); Ban (1998); Biercuk et al. (2009); Chen et al. (2018)), $U(\theta)$ can be approximated as $U(\theta)=I-i\theta H_{E}+O(t^{2})$. Since $\theta H_{E}\in\mathcal{E}$ regardless of $\theta$, this 3-qubit code corrects dephasing at order $O(t)$. More generally, $H_{E}^{q}$ contains Paulis of weight $\leq q$, so correcting to order $O(t^{q})$ with the repetition code requires $n=2q+1$ qubits (for $k=1$).

While the value of $\theta$ is unknown and varies from one run to the next, the coupling strengths $g_{j}$ are often fixed and well characterized. This suggests designing a code that corrects expressly for $\mathcal{E}=\text{span}\{I,H_{E},H_{E}^{2},\dots,H_{E}^{q}\}$, and depends on the $\{g_{j}\}$ in a particular device. A similar counting argument as above suggests that such a code would require $q+1$ subspaces to protect a logical qubit to order $O(t^{q})$, and therefore require

[TABLE]

qubits—an exponentially smaller overhead. We give a family of such codes here for general $q$ and arbitrary coupling strengths $\{g_{j}\}$. We focus in particular on the $q=1$ case, where one logical qubit is encoded in two physical qubits rather than three. We construct recovery and logical operations for this code, which can be implemented using a constant number of one- and two-qubit operations.

The decomposition $\mathcal{H}$ into subspaces $\mathcal{C}_{i}$ for QEC is equivalent to the Knill-Laflamme conditions Knill and Laflamme (1997); Bény (2011). For $k=1$ and $\mathcal{E}=\text{span}\{H_{E}^{j}\}_{j=0}^{q}$, these take the form

[TABLE]

for $0\leq m\leq 2q$, where we consider values of $q$ that saturate the ceiling in Eq. (3) (that is, $q=2^{n-1}-1$). Finding a QEC code that corrects this $\mathcal{E}$ therefore requires finding logical states ${|{0_{\textsc{l}}}\rangle}$ and ${|{1_{\textsc{l}}}\rangle}$ that satisfy Eqs. (4) and (5). We begin with the ansatz

[TABLE]

for $r_{j},\theta_{j},\phi_{j}\in\mathbb{R}$, where we use ${|{j}\rangle}$ to denote the $n$-bit binary representation of the integer $j$. That is, we fix the amplitudes of ${|{1_{\textsc{l}}}\rangle}$ to be those of ${|{0_{\textsc{l}}}\rangle}$ in reverse order. Notice that Eq. (6) always satisfies (4) for even $m\geq 0$, since $X^{\otimes n}H_{E}^{m}X^{\otimes n}=(-1)^{m}H_{E}^{m}$. For odd $m$:

[TABLE]

where $\vec{z},\,\vec{v}_{m}\in\mathbb{R}^{q+1}$ are defined as $z_{i}={\langle{i}|}Z_{\textsc{l}}{|{i}\rangle}$, with $Z_{\textsc{l}}:={|{0_{\textsc{l}}}\rangle}\!{\langle{0_{\textsc{l}}}|}-{|{1_{\textsc{l}}}\rangle}\!{\langle{1_{\textsc{l}}}|}$, and $(\vec{v}_{m})_{i}={\langle{i}|}H_{E}^{m}{|{i}\rangle}$ for $i\in[0,q]$ and odd $m\in[0,2q]$. Therefore, Eq. (4) is satisfied for all relevant $m$ if $\vec{z}\perp\text{span}\{\vec{v}_{m}\}$. We can always find such a $\vec{z}$ ($\neq\vec{0}$) since the $\vec{v}_{m}$’s have dimension $q+1$ but there are only $q$ of them, so they cannot form a complete basis. One approach is to construct a matrix $V$ with $\vec{v}_{m}$’s as columns; then, $I-VV^{+}$ projects onto $\text{span}\{\vec{v}_{m}\}^{\perp}$ (where $+$ and $\perp$ denote the pseudoinverse and orthogonal complement, respectively) and therefore has at least one real eigenvector $\vec{u}$ with unit eigenvalue 333Alternatively, the modified Gram-Schmidt procedure provides a less intuitive but more numerically stable method.. Taking $\vec{z}=\vec{u}/||\vec{u}||_{1}$ satisfies Eq. (4) since $\vec{u}\cdot\vec{v}_{m}=0$ automatically. Finally, building upon a technique developed in Ref. Layden et al. (2019) for optimization, we pick $r_{j}$’s as

[TABLE]

This choice ensures that ${\langle{j}|{0_{\textsc{l}}}\rangle}$ or ${\langle{j}|{1_{\textsc{l}}}\rangle}$ vanishes for every $j$, thus satisfying Eq. (5). We now have normalized logical states that form a valid QEC code for all $q\geq 1$. Notice that the components of ${|{0_{\textsc{l}}}\rangle}$ and ${|{1_{\textsc{l}}}\rangle}$ generically have unequal amplitudes $r_{j}$ by necessity, in marked contrast with classical error-correcting codes and most known QEC codes. The phases $\theta_{j}$ and $\phi_{j}$ can be chosen arbitrarily—we demonstrate a convenient choice below. The performance of these codes on $n\leq 5$ qubits is shown in Fig. 1 using an illustrative model of a normally-distributed $\theta$. In addition, we give the pseudothresholds for $n=2$ and 3 under the same model in the Supplemental Material SM .

To illustrate this QEC code, we consider explicitly the smallest case of $n=2$ qubits coupled to a two-level fluctuator with $\lambda_{\pm 1}=\pm 1$ [cf. Eq. (2)], at high temperature. We will label the register qubits 1 and 2 such that $|g_{1}|\geq|g_{2}|$. Note that here—and in general—$H_{E}=g_{1}Z_{1}+g_{2}Z_{2}$ is a combination of weight-1 Pauli operators, not a weight-2 Pauli. This $H_{E}$ gives $\vec{v}_{1}=(g_{1}+g_{2},g_{1}-g_{2})^{\top}$. The matrix $I-VV^{+}$ has only a 1-dimensional eigenspace with unit eigenvalue, spanned by $\vec{u}=(-g_{1}+g_{2},g_{1}+g_{2})^{\top}$, where $\vec{u}\cdot\vec{v}_{1}=0$. If $g_{1}>0$ we find $r_{1}=r_{3}=0$ and

[TABLE]

where $c=1/\sqrt{||\vec{u}||_{1}}$. This gives logical states

[TABLE]

with

[TABLE]

where ${|{0}\rangle}$ and ${|{1}\rangle}$ refer to the states of a qubit. The $g_{1}<0$ case gives the same result up to a relabelling of ${|{0_{\textsc{l}}}\rangle}\leftrightarrow{|{1_{\textsc{l}}}\rangle}$. This code corrects for $\mathcal{E}=\text{span}\{I,H_{E}\}$; by design, however, it does not correct for $Z_{1}Z_{2}$, nor $Z_{1}$ or $Z_{2}$ individually, none of which belong to $\mathcal{E}$. Rather, it corrects CFD with fewer qubits than the smallest repetition code precisely because we have chosen not to correct individual Pauli operators.

Observe that Eqs. (10) and (11) reduce to a DFS in the limit where one exists ($|g_{1}|=|g_{2}|$), but this is in practice rare. More generally, notice that the choice $\theta_{0}=\phi_{1}+\pi=-\theta_{2}=-\phi_{3}=\vartheta$ for arbitrary $\vartheta$ proves convenient: First, it gives ${\langle{\chi_{0}}|{\chi_{1}}\rangle}=0$, and a simple action of $H_{E}$ on logical states:

[TABLE]

Both lines have the same proportionality constant, and we have defined the error states ${|{0_{\textsc{e}}}\rangle}$ and ${|{1_{\textsc{e}}}\rangle}$. We emphasize that since $H_{E}$ cannot generically be decomposed as a tensor product, it maps most separable states to entangled states; Eq. (12)—wherein the first qubit is “flipped” by $H_{E}$—is due to our choice of ${|{0_{\textsc{l}}}\rangle}$ and ${|{1_{\textsc{l}}}\rangle}$. Second, consider the orthogonal projectors $P_{\textsc{l}}={|{0_{\textsc{l}}}\rangle}\!{\langle{0_{\textsc{l}}}|}+{|{1_{\textsc{l}}}\rangle}\!{\langle{1_{\textsc{l}}}|}$ and $P_{\textsc{e}}={|{0_{\textsc{e}}}\rangle}\!{\langle{0_{\textsc{e}}}|}+{|{1_{\textsc{e}}}\rangle}\!{\langle{1_{\textsc{e}}}|}$ onto $\mathcal{C}_{0}=\text{span}\{{|{0_{\textsc{l}}}\rangle},{|{1_{\textsc{l}}}\rangle}\}$ and $\mathcal{C}_{1}=\text{span}\{{|{0_{\textsc{e}}}\rangle},{|{1_{\textsc{e}}}\rangle}\}$ respectively ($\mathcal{H}=\mathcal{C}_{0}\oplus\mathcal{C}_{1}$). One can detect an error non-destructively by measuring parity in the ${|{\chi_{i}}\rangle}{|{j}\rangle}$ basis, which can be done by performing phase estimation (i.e., “phase kickback”) on

[TABLE]

with an ancilla Cleve et al. (1998). Crucially, the choice of phases in ${|{0_{\textsc{l}}}\rangle}$ and ${|{1_{\textsc{l}}}\rangle}$ makes $S$ separable here, where $U_{z}:={|{\chi_{0}}\rangle}\!{\langle{\chi_{0}}|}-{|{\chi_{1}}\rangle}\!{\langle{\chi_{1}}|}$ is a $\pi$ rotation about some axis determined by $g_{1}$, $g_{2}$ and $\vartheta$. This means that the controlled-$S$ (c$S$) operation used to measure the error syndrome can be implemented through a pair of two-qubit operations (c$U_{z}$ and c$Z$), rather than a more challenging 3-qubit operation. If an error is detected, it can be corrected by applying $U_{x}:={|{\chi_{0}}\rangle}\!{\langle{\chi_{1}}|}+{|{\chi_{1}}\rangle}\!{\langle{\chi_{0}}|}$ to qubit 1—a $\pi$ rotation about a different axis. (Both $U_{x}$ and $U_{z}$ could be synthesized out of a constant number of Pauli rotations, or implemented directly, e.g., by driving qubit 1 off resonance McKay et al. (2017).) The full recovery procedure, which corrects CFD to leading order, is shown in Fig. 2. Note that $S$ behaves like a stabilizer, in the sense of its action on $\mathcal{C}_{0}$ and $\mathcal{C}_{1}$. It does not, however, fit in the usual QEC stabilizer formalism since $\{H_{E},S\}\neq 0$ generically, because $\{H_{E},S\}\!{|{\psi}\rangle}=0$ for ${|{\psi}\rangle}\in\mathcal{C}_{0}$ but not for ${|{\psi}\rangle}\in\mathcal{C}_{1}$ Gottesman (1997). This is because $H_{E}$ maps $\mathcal{C}_{0}$ to $\mathcal{C}_{1}$ without distortion, but not vice-versa, as $H_{E}$ is not generically in the Pauli group. (Neither is $S$.) In spite of these unusual features, the procedure for feeding back on $S$ in Fig. 2 is largely the same as that of the usual stabilizer formalism. Finally, (i) the encoding can be realized by applying a $c_{2}(U_{x})_{1}$ gate to an initial state ${|{\chi_{0}}\rangle}{|{\psi}\rangle}$, and (ii) there is a simple way to implement any logical unitary $U_{\textsc{l}}$ in this code: apply the corresponding physical $U$ to qubit 2 followed by a recovery.

The logical states derived above are also valid for all $q>1$ (i.e., $n>2$ qubits), but the corresponding recovery and logical operations are generally more involved. Generically, the analogues of $S$ in (13) are not separable for any choice of $\theta_{j}$ and $\phi_{j}$ 444e.g., $S_{1}=P_{\textsc{l}}+P_{\textsc{e}\scriptscriptstyle 1}-P_{\textsc{e}\scriptscriptstyle 2}-P_{\textsc{e}\scriptscriptstyle 3}$ and $S_{2}=P_{\textsc{l}}-P_{\textsc{e}\scriptscriptstyle 1}+P_{\textsc{e}\scriptscriptstyle 2}-P_{\textsc{e}\scriptscriptstyle 3}$, which could be measured sequentially to identify an error for $n=3$. One might still synthesize them with one- and two-qubit operations, perform phase kickback through optimal control, or implement a QEC recovery via more general channel-engineering techniques Khaneja et al. (2005); de Fouquieres et al. (2011); Lloyd and Viola (2001); Shen et al. (2017). More efficient solutions could even be found by analyzing specific experimental scenarios. One approach could be for example to use devices with $\{g_{j}\}$ chosen so that the recovery and logical operations can be conveniently implemented. One could also correct to a slightly lower order $q$ [i.e., maintaining $n=O(\log q)$ but not saturating the ceiling in Eq. (3)]; this would yield a continuous family of possible $\vec{z}\,$’s [cf. Eq. (8)], among which one might find codes with convenient QEC operations. Note finally that for $n>2$ it is not the bare $H_{E}^{m}$’s that map the codespace to the orthogonal subspaces $\{\mathcal{C}_{i}\}_{i\geq 1}$, but rather linear combinations of them.

These noise-adapted QEC codes involve a trade-off: they correct CFD very efficiently at the cost of leaving most other errors uncorrected. For instance, errors during gates, due to miscalibration of $g_{j}$’s, or from decoherence beyond CFD will generally affect the logical state SM . Accordingly, these codes are manifestly not fault-tolerant in their current form Nigg et al. (2014). Crucially though, they offer such a large error budget under strong CFD—as evidenced by the gaps between QEC codes and physical qubits in Fig. 1—that this trade-off can easily be worthwhile, much like the targeted correction of photon loss in Ofek et al. (2016). Indeed, as we show in SM , the gap survives even in the presence of large miscalibration of the $g_{j}$’s. Fault-tolerance could still be achieved using implementation-specific methods as in Ref. Rosenblum et al. (2018). In the long-term, concatenation could potentially reach fault-tolerance, using our noise-adapted codes at the lowest level of encoding to protect against the dominant error source, and more conventional codes at higher levels. Even more importantly, our codes could have a near-term impact in applications such as quantum sensing and communication, where long-lived quantum memories are useful even when they are not fault-tolerant. We emphasize, however, that these codes are designed expressly for small- and medium-scale qubit registers, and that the exponential reduction in overhead should be understood to apply only in such devices. For one, there is typically a maximum $n$ above which CFD no longer dominates. Also, while the error budget always increases with $n$ in principle, so too do the effects of gate errors, miscalibration of $g_{j}$’s and decoherence beyond CFD, as more qubits introduce more error channels. Conversely, this growing sensitivity suggests an unconventional quantum sensing scheme to measure $\{g_{j}\}$ for large $n$, by variationally adjusting one’s estimates to maximize code performance. In the nearer term, however, these imperfections will likely set a maximum $n$ in any particular device beyond which one achieves no further gains, depending on their relative importance compared to CFD SM .

The QEC codes presented could be generalized in several ways. First, they can readily be made to correct dephasing due to multiple common fluctuators given enough qubits, at the cost of correcting to lower order in $t$. Similarly, they can correct spatially-correlated phase noise beyond that arising from common fluctuators. For instance, classical white noise in the energy gaps of register qubits leads to Lindblad error operators $L_{j}=\sqrt{\lambda_{j}}\,\vec{c}_{j}\cdot(Z_{1},\dots,Z_{n})$, where $\{\sqrt{\lambda_{j}}\,\vec{c}_{j}\}$ describes the noise’s normal modes Layden and Cappellaro (2018). In the limit of spatially uncorrelated noise the $L_{j}$’s become Pauli $Z$ operators; however, correlated noise produces $L_{j}$’s with unequal amplitudes $\sqrt{\lambda_{j}}$. When the noise correlations are appreciable, it could be advantageous to use a QEC code that corrects the stronger noise modes (those with large $\lambda_{j}$’s) to higher order in $t$ than the weaker ones (smaller $\lambda_{j}$’s) through an appropriate choice of $V$. It may also be possible to extend the codes presented here for the setting where a fluctuator’s state affects not only the energy gap of each qubit, but also the direction of its Hamiltonian (i.e., its quantization axis) Aiello and Cappellaro (2015). Eigenstate-preserving coupling arises frequently in practice because a large detuning between a weakly-coupled qubit and fluctuator suppresses non-commuting parts of their interaction Hamiltonian. However, when the coupling to the fluctuator is comparable to the internal Hamiltonian, such as for nuclear spins near defects in diamond, there can remain significant non-commuting terms leading to $H_{E}\sim\sum_{j}\vec{g}_{j}\cdot\vec{\sigma}_{j}$ in Eq. (2). We analyze this effect’s impact on code performance in SM . Extending the codes introduced here to this more general setting would make them even more widely applicable to near-term experiments, but at the cost of larger overheads, since they would need to contend with a substantially larger space of possible errors. It may be more practical instead to suppress non-commuting interaction terms at the hardware level by increasing the energy gaps $\omega_{j}$ of the register qubits, or at the “software” level through concatenation SM . Another interesting generalization would be to efficiently encode $k>1$ logical qubits, which seems plausible based on the counting argument used throughout involving the dimension of $\mathcal{H}$ versus $\mathcal{E}$. Finally, it would be interesting to use the tools presented here to design codes for other common error sources, such as other types of decoherence or control/measurement errors.

Our results demonstrate that it is possible to find noise-adapted QEC codes with a well-defined advantage (here exponential) over known, general codes. It is commonly argued that QEC will be of little use in Noisy Intermediate-Scale Quantum (NISQ) devices due to its prohibitive overhead Preskill (2018). Noise-adapted QEC codes are a promising way to reduce this overhead, although to date they have mostly relied on numerical and variational techniques that lack transparency in terms of what advantage the codes can offer, and when Reimpell and Werner (2005); Fletcher et al. (2007); Kosut et al. (2008); Taghavi et al. (2010); Johnson et al. (2017) (see also Lidar and Brun (2013) Ch. 13 and Noh et al. (2018)). In contrast, the codes introduced here exhibit a clear reduction in overhead under a well-characterized and common type of noise. New QEC codes of this type could provide a middle ground between small-scale uncorrected devices and large-scale fault-tolerant ones, where the dominant decoherence mechanisms are tamed through specialized codes with only modest overheads. This view of near-term QEC as quantum “firmware” rather than “software” suggests a possible interplay between theory and experiment, whereby NISQ hardware and efficient QEC codes both guide each other’s development.