Injection is all you need: parallel universal logic in high-rate concatenated self-dual codes

Introduction

High-rate quantum error-correcting (QEC) codes are enticing for their asymptotically low physical overheads as a quantum memory. However, it is often unclear how to use these codes for quantum computation. Strategies include generalized lattice surgery with suitably-constructed ancilla code patches [1, 2, 3, 4], logical gates based on code automorphisms [5, 6, 7, 8], and the direct circuit-level construction of logical gates that address a chosen subset of the logical qubits in a code block [9, 10, 11, 12]. A fundamental problem for high-rate codes is that they generally suffer from an addressability problem [13, 14, 15], which seemingly limits computational bandwidth (active circuit width) by limiting the number of logical qubits that can be processed simultaneously, forcing logically disjoint gates to be serialized.

In this work, we take a different route that avoids the addressability problem: rather than building addressable logical gates into the code, we inject all but a handful of logical gates via Steane-QEC and Knill-QEC teleportation gadgets that consume fault-tolerantly prepared resource states. A byproduct of these injections is that we simultaneously perform QEC and mitigate leakage noise by teleporting the logical information into fresh qubits. Our scheme is designed for a specific and practically-motivated family of codes: concatenated codes built from self-dual CSS seed codes, called self-dual with equivalent logicals (SWEL) [12, 16], that have transversal global logical Hadamard ($H$) and phase ($S=\operatorname{diag}(1,i)$) operators. Specifically, an $\lbrack n,k\rbrack$ SWEL code is a self-dual CSS code for which $\bar{H}^{\otimes k}=H^{\otimes n}$ and $\bar{S}^{\otimes k}\cong_Z S^{\otimes n}$, where $\bar{H}$ and $\bar{S}$ denote logical $H$ and $S$ operators, and $\cong_Z$ denotes equality modulo single-qubit $Z$ gates [17]. This restriction enables the fault-tolerant construction of resource states suitable for highly parallel universal quantum computation with high-rate concatenated codes [10]. We sketch out the general scheme in Figure 1.

Our approach to executing Clifford circuits is inspired by Ref. [18], which showed that an arbitrary logical Clifford circuit can be injected by consuming a constant number of resource states, one per stage of a Bruhat decomposition [19]. In that work the requisite resource states are generically non-CSS and are produced by a costly distillation protocol. Our key observation is that the availability of global $H$ and $S$ gates allows every stage of the decomposition to be reduced to a CSS resource state; an arbitrary $k$-qubit logical Clifford can then be injected using at most 9 CSS resource states. Fault-tolerant preparation circuits for these CSS states are found without distillation using the flag-at-origin method of Ref. [20]. We emphasize that the tools underlying our construction of Clifford gates depend only on the use of SWEL codes (or, more generally, fault-tolerant logical $\bar{H}^{\otimes k}$ and $\bar{S}^{\otimes k}$ gates). In particular, neither code concatenation (as the method for code construction) nor flag-at-origin (as the method for CSS resource state preparation) are required for our fault-tolerant Clifford gates. Nonetheless, code concatenation is essential for our construction of a high-

rate fault-tolerant magic resource state factory.

To complete a universal gate set we must inject a non-Clifford gate, for which we use consumable logical $|H\rangle^{\otimes k}$ magic states. Here the transversal $\bar{H}^{\otimes k}$ gate plays a second, distinct role: because $\bar{H}^{\otimes k}$ is transversal, it can be measured fault-tolerantly, providing a built-in flagging mechanism that detects errors in the magic-state preparation. On its own, a single such parity measurement suppresses magic-state infidelity to only $O(p^2)$, since the measurement of $\bar{H}^{\otimes k}$ can only resolve the parity of faulty logical qubits. Combining this flagging mechanism with code concatenation, however, lets us cross-verify independent parity measurements at successive levels and drive the probability of an undetectable logical error down to $O(p^{2^\ell})$ at concatenation level $\ell$. We refer to this procedure as concatenated cultivation. It is closely related to the protocols explored in [21, 22, 23, 24].

Logical Clifford gates

Quantum teleportation is known to be a universal logical primitive [25]. Consider a $k$-qubit unitary $U=\sum_{a,b\in\{0,1\}^k}U_{ab}|a\rangle\langle b|$ that we wish to apply to the $k$ logical qubits of a single code block, initially in the logi cal state $|\psi\rangle$. This unitary can be injected by the circuit

where we identify a sub-circuit that prepares the state $|\Phi,U\rangle= \frac{1}{2^k}\sum_{a,b\in\{0,1\}^k} U_{ab}|ba\rangle$, the bitstrings $x,z\in\{0,1\}^k$ are logical measurement outcomes, and throughout this work we adopt the notation $V^{\otimes v}=\bigotimes_{j=1}^{|v|}V^{v_j}$ for any single-qubit unitary $V$ and integer vector $v=(v_1,v_2,\cdots)$. If $U$ is Clifford, then $UX^{\otimes z}U^\dagger$ and $UZ^{\otimes x}U^\dagger$ are Pauli strings.

At face value, Eq. (1) merely converts the problem of applying $U$ to $|\psi\rangle$ into the problem of applying $U$ to the second register of $k$ Bell pairs. However, if we can prepare $|\Phi,U\rangle$ directly, then Eq. (1) tells us how to consume this state to inject $U$ to an arbitrary $k$-qubit state $|\psi\rangle$. We have thus reduced the problem of applying $U$ to that of preparing the resource state $|\Phi,U\rangle$.

While fault-tolerantly preparing $|\Phi,U\rangle$ may be difficult in general, if $U$ is Clifford then we can simplify our task via the Bruhat decomposition [19] $U=\prod_{j=1}^{9}U_j$ into Cliffords $(U_1,U_2,\cdots,U_9)$ with type signature $(\mathrm{CX},S,\mathrm{CX},S,H,S,\mathrm{CX},S,\mathrm{CX})$ as in Figure 1(b). Here a Clifford of type CX, H, or S can be exclusively built, respectively, out of CNOT, $H$, or $S$ gates. Ref. [18] thereby proposed to inject an arbitrary Clifford $U_j$ by consuming the resource states $|\Phi,U_j\rangle$, for which the authors designed suitable fault-tolerant distillation protocols. The idea is to use faulty state preparation and then concatenate with classical codes $[n_z,k_z,d_z]$ and $[n_x,k_x,d_x]$. If $d_x,d_z>d$, then $n_xn_z$ noisy copies of the CSS state $|\psi\rangle$ can be distilled into $k_xk_z$ copies of $|\Phi,U_j\rangle$ with fault distance $d$. The strength of this approach is clear when many copies of the same state $|\Phi,U_j\rangle$ are required. However, the Bruhat decomposition does not generically require many copies of each resource state. To produce a single copy of $|\Phi,U_j\rangle$ via distillation, the optimal choice is to use the classical repetition code $[d+1,1,d+1]$, which means that each distillation factory requires $n(d+1)^2$ qubits.

Here, we keep the idea of consuming resource states to inject Cliffords, but replace distillation by the distillation-free flag-at-origin method of Ref. [20]. An immediate obstruction to this approach is that flag-at-origin can only fault-tolerantly prepare CSS states that are stabilized by Pauli-$X$ and Pauli-$Z$ strings, whereas the resource states $|\Phi,U_j\rangle$ are generally non-CSS. However, we can overcome this obstruction if we restrict our attention to SWEL codes, which have fault-tolerant logical global $S^{\otimes k}$ and $H^{\otimes k}$ gates [16, 26] that act on all logical qubits.

Proof. Decompose the $k$-qubit Clifford unitary $U=\prod_{j=1}^{9}U_j$ into a sequence of nine circuits with type signature $(\mathrm{CX},S,\mathrm{CX},S,H,S,\mathrm{CX},S,\mathrm{CX})$, using the Bruhat decomposition [19]. If each of the circuits $U_j$ is fault-tolerant (and sufficient QEC is performed in between, to form suitable extended rectangles [27]), then the unitary $U$ is fault-tolerant. There are three types of circuits to consider in this decomposition.

(1) CNOT (CX) type: Each CX-type circuit $V$ consists of only CNOT gates, so the corresponding resource state $|\Phi,C\rangle$ can be obtained by applying logical CNOT gates to logical Bell states of a CSS code, which are altogether CSS states.

(2) Phase (S) type: Without loss of generality, each S-type circuit can be written in the form $S^{\otimes z}Z^{\otimes s}$ for some pair of bitstrings $s,z\in\{0,1\}^k$. The logical $Z^{\otimes z}$ gate can be implemented directly with physical single-qubit Pauli-$Z$ gates, which is fault-tolerant. For the logical $S^{\otimes s}$ gate, by assumption we can fault-tolerantly prepare tensor products of logical $|0\rangle$ and $|+\rangle$ states, and in particular the state $H^{\otimes s}|0\rangle^{\otimes k}$, which is $|+\rangle$ on the qubits where $s$ is 1, and $|0\rangle$ elsewhere. In turn, we can use global operations to convert $H^{\otimes s}|0\rangle^{\otimes k}$ into the state

where $\simeq$ denotes equality up to global phase. This state is $|i\rangle=|0\rangle+i|1\rangle$ on the qubits where $s$ is 1, and $|+\rangle$ elsewhere. Transversally injecting the rotation-gate teleportation gadget

where $P(\theta)=\exp(-i\frac{\theta}{2}Z)$ and in particular $P(\frac{\pi}{2})=S$, fault-tolerantly applies the gate $S^{\otimes s}$ to one code block [28].

(3) Hadamard (H) type: Without loss of generality, every H-type circuit can be written in the form $H^{\otimes h}$ for some bitstring $h\in\{0,1\}^k$. By decomposing $H=XS_Y$, where $S_Y=\exp(-i\frac{\pi}{4}Y)$ is an $S$ gate in the $Y$ basis, and in turn $S_Y \simeq(SH)S(HS^\dagger)$, we can expand

The addressable $H^{\otimes k}$ gate thus reduces to physical Pauli-$X$ gates, global $S^{\otimes k}$ and $H^{\otimes k}$ gates, and an addressable $S^{\otimes h}$ gate, all of which are fault-tolerant.

The takeaway from Theorem 1 is that by using Knill-QEC gadgets for CNOT layers (Eq. (1) and Figure 1(e)) and Steane-QEC gadgets for single qubit Cliffords (Eq. (3) and Figure 1(c,Figure 1d)), we can perform arbitrary $k$-qubit Clifford gates by consuming at most 9 CSS resource states. Furthermore, the process of consuming resource states passively performs quantum error correction and leakage mitigation in tandem with the execution of the circuit.

As a final point, we comment on the implementation of Clifford gates between code blocks, which by the Bruhat decomposition reduces to the task of implementing a CNOT circuit on multiple code blocks. A CNOT circuit that addresses a pair of $\llbracket n,k,d\rrbracket$ SWEL code blocks can be injected by treating them as a single $\llbracket2n,2k,d\rrbracket$ code block and applying the Knill-QEC injection of Figure 1(e). An alternative route for identical $\llbracket n,k,d\rrbracket$ SWEL blocks is to combine their transversal inter-block CNOT with (injected) intra-block CNOTs, as in Refs. [9 Figure 9(a)] and [29 Figure 7(a)]. Finally, inter-block CNOTs may be implemented via the construction of homomorphic CNOTs [30] or generalized lattice surgery [1, 2, 3, 4]. Unlike the CNOT circuits that are injected with a CSS resource state, however, inter-block CNOTs applied with techniques that rely on addressability typically need to be divided into layers of disjoint logical gates, and implemented one layer at a time, hindering the parallelism of the injection architecture. It is therefore important to minimize such inter-block CNOT gates, for example by developing a suitable compiler or using an architecture in which the primary purpose of these gates is to teleport information into and out of a large SWEL processing block.

Logical non-Clifford gates

To complete a computationally universal gate set, we need to show how to perform a logical non-Clifford gate. Recall that any single-qubit rotation $U$ can be approximated to arbitrary precision by a sequence of alternating $T$ and $H$ gates: $U \approx U_L(T^{\pm}HT^{\pm}HT^{\pm}\cdots HT^{\pm})U_R$, where $U_L$ and $U_R$ are Clifford. Below, we will show how $|H\rangle^{\otimes k}$ can be used as a resource state for addressable $T$ gates within a code block, where $|H\rangle$ is a $+1$ eigenstate of $H$. We will then discuss how to prepare high-fidelity $|H\rangle^{\otimes k}$ states in concatenated SWEL codes. In particular, we show that repeated use of logical Hadamard measurements gives a state preparation protocol for $|H\rangle^{\otimes k}$ where

the probability of an undetectable logical error is $O(p^{2^\ell})$ in the physical error rate $p$ and concatenation level of $\ell$.

Universality using $|H\rangle^{\otimes k}$

Proof. For the purposes of this proof it is sufficient for us to show how to implement an addressable logical gate of the form $T^{\otimes t}$ with $t=(t_j:j\in\mathbb{Z}_k)\in\{0,1\}^k$.

As a warm up, setting $\theta=\frac{\pi}{4}$ in Eq. (3) recovers a gadget that consumes a $|T\rangle=SHS|H\rangle$ state to inject a $T$ gate. A $T^{\otimes k}$ gate can therefore be applied to the $k$ qubits of a code block by consuming a $|T\rangle^{\otimes k}=S^{\otimes k}H^{\otimes k}S^{\otimes k}|H\rangle^{\otimes k}$ state in parallel using a transversal CNOT gate and an addressable logical $SX$ correction.

A logical $T^{\otimes t}$ gate can similarly be applied by using the gadget in Eq. (3) with the resource state $T^{\otimes t}|+\rangle^{\otimes k}$. To this end, we expand

where

In turn, we can prepare $|H,t\rangle$ from $|H\rangle^{\otimes k}$ by consuming one $H^{\otimes t}|0\rangle^{\otimes k}$ state:

In total, $T^{\otimes t}|+\rangle^{\otimes k}$ state can be prepared from one $|H\rangle^{\otimes k}$ state and one $H^{\otimes t}|0\rangle^{\otimes k}$ state. Consuming the $T^{\otimes t}|+\rangle^{\otimes k}$ state using the gadget in Eq. (3), which requires a transversal CNOT gate and an addressable logical $SX$ correction, then applies a logical $T^{\otimes t}$ gate as depicted in Figure 1(f).

We remark that the sign of individual $T$ gates in $T^{\otimes k}$ can be flipped by sandwiching a $T$ gate with transversal $X$ gates. Control over logical signs $\sigma\in\{+1,-1\}^k$ in $T^{\otimes\sigma}$ also enables an injection of $T^{\otimes o}$ for any odd integers $o\in(2\mathbb{Z}+1)^k$ by decomposing $T^{\otimes o}\simeq T^{\otimes o'}\cdot Z^{\otimes o''}$, where $\simeq$ denotes equality up to global phase, and the exponents $o^{T} \in\{+1,-1\}^{k}$ and $o^{Z} \in\{0,1\}$ are defined by

High fidelity $|H\rangle^{\otimes K}$ states via concatenated cultivation

Being able to prepare $|H\rangle^{\otimes K}$ fault-tolerantly on the final $[[N,K,D]]$ $L$-level concatenated code is of paramount importance. Here, we present a method for producing these states in concatenated codes $\mathbf{C}=C_{1}\circ C_{2}\cdots\circ C_{L}$, where each $C_{j}$ is a SWEL code with parameters $[[n_{j},k_{j},d_{j}]]$. The idea, which we refer to as concatenated cultivation is to iteratively use the zero-level distillation (ZLD) procedure described below to create $k$ magic states with an infidelity that is $O(p^{2^{\ell}})$ in the physical error rate $p$ and concatenation level of $\ell$. Conveniently, these codes also satisfy the conditions of Theorem 1, making them suitable for universal fault-tolerant quantum computation.

Similar approaches to creating high fidelity magic states in concatenated codes were studied in [21, 22]. Without specifying these details, the $O(p^{2^{\ell}})$ suppression quoted above is really a statement about the probability of an undetectable logical error occurring. We elaborate on this point in Section III B 3 and Section IV, where we study concatenated cultivation circuits for specific example codes.

Zero-level distillation (ZLD)

Suppose we prepare the state $|H\rangle^{\otimes k}$ in a SWEL code with parameters $[[n,k,d]]$. Since $H^{\otimes k}$ is transversal and a stabilizer of $|H\rangle^{\otimes k}$, we can measure it fault-tolerantly and post-select on measurement outcomes of $M_{H^{\otimes k}}=+1$, thereby boosting the fidelity of $|H\rangle^{\otimes k}$. Schematically, after appending a round of code-stabilizer measurements the net state preparation circuit looks like

where the measurement of $H^{\otimes k}$ can be performed by transversally applying the circuit

This trick has been used previously in topological and concatenated codes [21, 22, 31, 32]. In the case of $k=1$, Ref. [31] explains how $O(d)$ Hadamard measurements can be used to obtain a logical infidelity of $O(p^{\lfloor(d+1)/2\rfloor})$. The situation for $k>1$ is different because a parity measurement of $H^{\otimes k}$ is insensitive to, for example, an even number of $Y$ errors in $|H\rangle^{\otimes k}$. Repeated measurements of $H^{\otimes k}$ can therefore at best suppress the infidelity of $|H\rangle^{\otimes k}$ to $O(p^{2})$. For this reason, we only require that in the circuit to initially prepare $|H\rangle^{\otimes k}$, all individual faults are detected by the $H^{\otimes k}$ or stabilizer measurements.

To this end, we identify the potentially “problematic” Pauli errors that would pass the checks in Eq. (10) after the initial preparation of $|H\rangle^{\otimes k}$. Any Pauli error with destabilizer factors is caught by the code stabilizer measurements, so we need only consider pure logical errors. As an illustrative example, consider the pure logical error $X_{1}Z_{2}Y_{3}$, which acts on $|H\rangle^{\otimes k}$ as

where $|-H\rangle$ is the $-1$ eigenstate of $H$, and $|\pm\widetilde{H}\rangle\propto|H\rangle\pm|-H\rangle$ is the $\pm1$ eigenstate of $\widetilde{H}=(X-Z)/\sqrt{2}$. A $+1$ measurement of $H^{\otimes k}$ fails to project onto $|H\rangle^{\otimes k}$ if any two of $X_{1}$, $Z_{2}$, or $Y_{3}$ are present, leading to a general criterion for detectability in Eq. (10):

Condition 1 (Detectability Condition). In order for a mid-circuit Pauli error to be detectable by the stabilizer measurements in Eq. (10), it must be equivalent either to a single (pure logical) Pauli-$X$, a single Pauli-$Z$, or a product of an odd number of Pauli-$Y$ operators.

If a non-fault-tolerant $|H\rangle^{\otimes k}$ state preparation circuit possess error mechanisms that violate Condition 1, then flag gadgets can be added to catch these errors. We discuss the addition of flag gadgets in more detail in Appendix § 2.1.3. We provide an encoding circuit that satisfies Condition 1 for the $[[15,7,3]]$ Hamming code in Figure 4 of Section IV B, and encoding circuits for an entire family of $[[k+4,k,2]]$ H codes in Appendix § 2.1.2.

Concatenated cultivation

In concatenated codes we can overcome the $O(p^{2})$ barrier by applying ZLD at each level of concatenation to verify parity for independent batches of logical states. Cross-referencing the measurement outcomes from the different levels of concatenation allows us to bound the logical error rate. In order for cross-referencing to work in a concatenated code $\mathbf{C}=C_{1}\circ C_{2}\cdots\circ C_{L}$, each code $C_{j}$ in the sequence must have transversal global $H^{\otimes k_{j}}$ gate. This method generalizes that in Ref. [22] to the concatenation of any SWEL codes equipped with circuits that satisfy Condition 1.

It will be helpful to define some terminology and notation: we refer to the logical qubits at $\ell$ levels of concatenation as level-$\ell$ qubits. That is, level-0 qubits are physical qubits, level-1 qubits are the logical qubits of $C_1$, level-2 qubits are the logical qubits of $C_1 \circ C_2$, and so on. We will use integer subscripts on a quantum state, as in $|\psi\rangle_\ell$, to denote that it is expressed as a state of level-$\ell$ qubits. In fact, we will only need to consider $\ell\le2$ below, as the code $C_1 \circ C_2 \circ C_3$ can be obtained by concatenating $(C_1 \circ C_2)$ with $C_3$, so the generalization of our discussions below to the case of $\ell> 2$ follows by induction.

Consider the codes $C_1$ and $C_2$, with parameters $[\![n_1,k_1,d_1]\!]$ and $[\![n_2,k_2,d_2]\!]$, concatenated into the code $C=C_1\circ C_2$ with parameters $[\![N,K,D]\!]=[\![n_1n_2,k_1k_2,d_1d_2]\!]$. Specifically, we consider a generalization of tree-style concatenation, visualized in Figure 2: each logical (level-1) qubit of a $C_1$ code block is assigned to a distinct $C_2$ code block, such that in total we concatenate $n_2$ copies of a $C_1$ code block with $k_1$ copies of a $C_2$ code block.

To prepare $|H\rangle_2^{\otimes K}$, we first prepare $k_2$ copies of $|H\rangle_1^{\otimes k_1}$ using ZLD with $C_1$, and prepare $n_2-k_2$ copies of a $C_1$ code block initialized into $|0\rangle_1^{\otimes k_1}$. We thereby prepare, in effect, $k_1$ copies of the state $|H\rangle_1^{\otimes k_2}|0\rangle_1^{\otimes(n_2-k_2)}$. We then consider an encoding circuit for $C_2$, which nominally maps the input state $|H\rangle_1^{\otimes k_2}|0\rangle_1^{\otimes(n_2-k_2)}$ to the encoded state $|H\rangle_2^{\otimes k_2}$ using only level-$\ell$ Hadamard gates, CNOT gates, and the readout or preparation of level-$\ell$ ancilla qubits in the $X$ and $Z$ bases. The $k_1$-fold tensor product of this encoding circuit similarly maps $k_1$ copies of $|H\rangle_1^{\otimes k_2}|0\rangle_1^{\otimes(n_2-k_2)}$ onto $k_1$ copies of $|H\rangle_2^{\otimes k_2}$ using level-1 gates that are transversal in $C_1$. The encoding circuit for $C_2$ is required to satisfy Condition 1 for compatibility with ZLD.

with ZLD.

So far, we have encoded level-1 qubits into level-2 qubits, noisily preparing $k_1$ copies of $|H\rangle_2^{\otimes k_2}$. We now need to measure Hadamard operators $H^{\otimes k_2}$ for ZLD at the second level of concatenation. To this end, we nominally consider using one level-1 ancilla qubit to measure $H^{\otimes k_2}$ on the logical (level-2) qubits of each $C_2$ code block, with the circuit

This circuit should be thought of as a formal object, having a well-defined logical action despite using gates with level-1 control and level-2 target qubits.

Transversality of $H^{\otimes k_2}$ in $C_2$ means that the level-2 $H^{\otimes k_2}$ gate across a $C_2$ code block in Eq. (14) is equivalent to a $H^{\otimes n_2}$ gate on level-1 qubits. This push-through makes the $q$-th level-1 ancilla qubit in Eq. (14) address $q$-th logical qubit of each $C_1$ code block (see Figure 2), which we can write in terms of transversal controlled-Hadamard gates between the logical (level-1) qubits of $C_1$ code blocks as

Each wire in Eq. (14) corresponds to one $C_1$ code block, allowing the transversal controlled-Hadamard gates to be implemented by decomposing $H=T Y Z T^\dagger$, as in Eq. (11). Finally, to make this circuit have level-1-fault distance 2, we replace the ancilla $C_1$ code block with a pair of $C_1$ code blocks that store $k_1$ Bell pairs,

Up to half of the transversal two-qubit gates in Eq. (15) can be applied from the second ancilla code block rather than the first, cutting the circuit depth of Eq. (15) by nearly half.

To recap, after the first round of ZLD we prepare $k_2$ copies of $\lvert H\rangle_1^{\otimes k_1}$, with a logical error rate $O(p^2)$. We then run $C_2$ encoding circuits transversally across $C_1$ code blocks to prepare $\lvert H\rangle_2^{\otimes K}$. Finally, to perform ZLD at the second level of concatenation, which requires measuring a level-2 $H^{\otimes k_2}$ operator in each $C_2$ code block (as in Eq. (14)), we use the level-1 circuit in Eq. (15) to measure $H^{\otimes n_2}$ operators distributed across $C_1$ code blocks. Whereas the parity measurement of $H^{\otimes k_1}$ can be blind to block-local physical errors of weight 2, these errors get caught by the cross-block measurements of $H^{\otimes n_2}$. Weight-3 errors are similarly caught by the parity measurements for ZLD, altogether giving the post-selected $\lvert H\rangle_2^{\otimes K}$ state a logical error rate of $O(p^4)$. By induction, iterating this procedure for $L$ levels of concatenation yields magic states with a post-selected logical error rate of $O(p^{2^L})$. We remark that if the concatenated code is built from seed codes with distance $d_j \ge2$, then the concatenated code distance $D = \prod_{j=1}^{L} d_j \ge2^L$, so $O(p^{2^L}) \ge O(p^D)$.

Code distance versus cultivation distance

The $O(p^{2^L})$ probability of a logical error from concatenated cultivation is the probability of a pure logical error, with no destabilizer factors. However, concatenated cultivation still leaves errors of weight $w$ with probability $O(p^w)$. If the concatenated code distance $D$ is insufficiently large, the true probability of a logical error when consuming the cultivated state $\lvert H\rangle_L^{\otimes K}$ in an error-corrected algorithm may instead be limited by the maximal error weight that can be reliably corrected in the code, namely $t = \lfloor(D-1)/2\rfloor$. The effective logical error rate of $\lvert H\rangle_L^{\otimes K}$ is therefore $O(p^{\min\{2^L,t+1\}})$. As an example, a weight-3 error in a $\llbracket90,14,6\rrbracket= \llbracket6,2,2\rrbracket\circ\llbracket15,7,3\rrbracket$ code is detectable by stabilizers, but may be decoded incorrectly, increasing the $O(p^4)$ logical error rate of the $\lvert H\rangle_2^{\otimes14}$ state to $O(p^3)$.

The inability to accommodate the $O(p^{2^L})$ logical error rate is similar to what happens with magic state cultivation on the surface code [32], where the fidelity of the logical state produced in a distance-3 color code is too high to survive decoding in the original code, which must in turn be grown into a larger surface code that can accommodate the low error rate of the state. The examples benchmarked in this work fall into the same category of codes for which $t+1 < 2^L$. We provide a detailed discussion of decoding in Section IV A, where we explain how to restore, at least partially, the level of error suppression provided by concatenated cultivation by incorporating post-selection into the decoding process.

If $2^L < t+1$, we make full use of concatenated cultivation, but in this case the cultivated state does not exploit the full error-correcting capability of the distance-$D$ code. The resulting excess distance provides some “slack” when designing the cultivation circuit. Concatenated cultivation iteratively uses a fault-tolerant encoding circuit for each seed code $C_i$ with distance $d_i$, but the circuit fault distance need not equal the distance $d_i$ of that seed code. Instead, only a fault distance of 2 is needed at each concatenation level, simplifying the task of designing the full concatenated cultivation circuit. This flexibility can also be used to reduce quantum resources. Suppose we are targeting a suppression, after decoding, of $O(p^4)$. The required code distance can be accomplished by a $L=3$ code with distance-2 seed codes, or a $L=2$ code with distance-3 seed codes. The latter code involves fewer concatenations, which generally translates to more favorable post-selection rates and spacetime volumes. This tradeoff has obvious implications for code choice and architecture design.

Concrete examples

In this section, we numerically benchmark the performance of the flag-at-origin and concatenated cultivation state preparation protocols on three example codes with concatenation level $L=2$:

The seed codes of $\llbracket36,4,4\rrbracket$, $\llbracket48,8,4\rrbracket$, and $\llbracket96,14,6\rrbracket$ are all SWEL codes. See Appendix § 2.1.1 for explicit stabilizers and our choice of logical operators for the seed codes. The $\llbracket6,2,2\rrbracket$ and $\llbracket8,4,2\rrbracket$ are the smallest instances of the family of $\llbracket k+4,k,2\rrbracket$ H codes (limited to even $k$) [23, 33], all of which are also SWEL. We provide additional benchmarks of cultivated magic states in level-2 concatenated codes built from $\llbracket k+4,k,2\rrbracket$ H codes in Appendix § 2.1.2.

Noise and decoding

Our numerical benchmarks use a depolarizing noise model with the following parameters:

Fault	Channel	Applied	Rate
Initialisation/Reset	1-qubit depolarising	after	$p$
Two-qubit gate	2-qubit depolarising	after	$p$
Measurement	1-qubit bit-flip	before	$p$
Single-qubit gate	1-qubit depolarising	after	$p/100$
Idling (memory)	1-qubit depolarising	during idle	$p/100$

To compute the logical error rates of a noisy concatenated cultivation circuit, sketched in Figure 5, we append a noiseless round of syndrome measurements. We then decode with a lookup table decoder built using a code-capacity depolarizing noise model for the concatenated code. The lookup table stores all syndromes generated by errors up to weight $t$. If the syndrome produced by a sample is not recognized by the decoder, then the decoder declares erasure and the state is rejected, which contributes $O(p^{t+1})$ to the overall post-selection rate. The scaling is important for overall scalability because decoder-heralded post-selection occurs “online” in the sense that the stabilizer measurements that the decoder receives are a by-product of a state injection. Post-selection here then means aborting an entire circuit, rather than merely restarting a repeat-until-success protocol, so it is crucial that this event is suppressed in $p$.

When $D$ is even, as is the case for all of our example codes, online post-selection has the added benefit of suppressing logical errors from $O(p^{t+1})$ to $O(p^{t+2})$. In this case, if two errors $E_{\mathrm{small}}$ and $E_{\mathrm{big}}$ with weights $|E_{\mathrm{small}}| \le t$ and $|E_{\mathrm{big}}| > t$ have identical syndromes, they can only differ in their logical operator content if $|E_{\mathrm{big}}| \ge D-t=t+2$. The logical error rate of a state prepared by concatenated cultivation therefore becomes $O(p^{\min\{2^{L},t+2\}})$. This can be contrasted with a pure post-selection protocol, wherein no decoder is used and any syndrome violation leads to the state being rejected. This approach will saturate the $O(p^{2^L})$ suppression but at the expense of an $O(p)$ “online” post-selection which limits the depth of executable logical circuits. As a concrete example, preparing $|H\rangle^{\otimes4}$ in the $[\![6,2,2]\!] \circ[\![6,2,2]\!]$ code via concatenated cultivation was previously studied in [22]. The benchmarking therein was done using pure post-selection on stabilizer measurements with the logical error rate and “online” post-selection scaling as $O(p^4)$ and $O(p)$. For this case, the superior logical error rate cannot be fully taken advantage of because the $O(p)$ post-selection will severely limit the number of magic state injections that can be performed. When employing a decoder (see Section IV B) these same quantities are more balanced, logical error rate and “online” post-selection scale as $O(p^3)$ and $O(p^2)$, allowing for deeper logical circuits.

Benchmarking magic states

In this section we describe the encoding circuit for $|H\rangle^{\otimes k}$ in more detail, and present numerical performance results for Clifford proxy circuits which mimic the structure of the aforementioned circuits.

$|H\rangle^{\otimes k}$ encoding circuits

In order to prepare $|H\rangle^{\otimes K}_2$ in our concatenated codes, we first need to identify encoding circuits for $|H\rangle^{\otimes k}_1$ in each of the seed codes. A strategy for arbitrary seed codes is to start with a general unitary encoding circuit, and then add flag gadgets to catch all single faults that violate Condition 1. We found that the family of $[\![k+4,k,2]\!]$ H codes admit encoding circuits that satisfy Condition 1 without flag gadgets (see Appendix B). Figure 3 shows the corresponding encoding circuit (followed by a Hadamard measurement gadget) for the $[\![6,2,2]\!]$ H code.

For the $[\![15,7,3]\!]$ Hamming code, we were unable to find an unflagged encoding circuit that satisfies Condition 1. We therefore start with a compact general encoding circuit, produced using the Munich Quantum Toolkit (MQT) [34], and use flag gadgets to catch “problematic” errors that violate Condition 1, such as that in Eq. (12). We thereby arrive at the encoding circuit in Figure 4. We discuss the procedure of adding flag gadgets in Appendix C, and remark that there may be ample room for optimizing this procedure to further reduce the logical error and discard rates of an encoding circuit, which we leave for future work.

Details of magic state proxy circuits

The concatenated cultivation circuits for preparing $|H\rangle^{\otimes K}_2$ with the example codes in Eqs. (16) to (18) are non-Clifford and too large for direct benchmarking (though recent developments in classically simulating Clifford+$T$ circuits bring the prospect of direct benchmarking closer [35]). We therefore benchmark concatenatenated cultivation by simulating the cultivation of a Clifford proxy state, $|+\rangle^{\otimes K}$. These proxy simulations allows us to test the scaling predictions in Section IV A, and estimate logical error and discard rates. Error and post-selection rates are reported subject to the noise model and decoder described in Section IV A. The structure of the encoding circuit is shown Figure 5.

The first step is to run the fault-tolerant encoding circuit on all $C_1$ code blocks. In the examples we analyze, this corresponds to the encoding circuit for the $[[6,2,2]]$ H code shown in Figure 3, but with the $CH$ gates replaced by $CX$ gates. We then implement the fault-tolerant encoding circuit of $C_2$ using the logical gates of $C_1$.

We then perform a logical operator measurement using a Clifford proxy for the circuit in Eq. (15), replacing $CH$ gates by $CX$ gates to measure a logical $X^{\otimes k}$ operator. Recall from Eq. (11) that performing $CH$ requires two injections of $T_Y$ gates. Our proxy for these $T_Y$ gates is to sandwich the $CX$ gate in a standard measurement gadget by two trivial (identity-gate) injections on either side, which are stand-ins for the two injections necessary for a $T$ gate (the “bare” $T$-state injection and a feed-forward $S$ gate). In total, our Clifford proxy for each $CH$ gate in Eq. (15) is the gadget

A quick comment on the overheads of this gadget. The example codes $[[36,4,4]]$, $[[48,8,4]]$, and $[[96,14,6]]$ all use the $[[6,2,2]]$ H code for their level-1 code blocks, which only requires an $S$ injection half of the time because the feed-forward gates for $T^{\otimes2}$ are uniformly random on $\{I,S\}$ (and $S^{\otimes2}$ is transversal). On average then, executing the level-2 Hadamard measurement will require $3n_2$ injections of level-1 states: $2n_2$ for the $T$-state injections and $n_2$ (on average) for the feed-forward $S$ gates. Our proxy simulations restrict to the worst case; every level-2 $X^{\otimes k}$ measurement includes $4n_2$ injections of level-1 states. In the results reported below, we do not post-select on the syndrome outcomes of the level-1 ancilla code blocks used for the injections, though this is an extra filter that can be incorporated.

The final step of concatenated cultivation is to measure stabilizers of the concatenated code. We perform one round of level-1 stabilizer measurements on each level-1 code using level-0 (physical) Bell-state ancilla qubits (see Figure 11 in Appendix § 2.1.3.2). For code $[[96,14,6]]$ with $d_2>2$, we then measure level-2 stabilizers using a level-1 Bell-state ancilla code blocks. In the case of $d_2=2$ (codes $[[36,4,4]]$ and $[[48,8,4]]$) we do not measure level-2 stabilizers because doing so does not (asymptotically) reduce the $O(p^2)$ probability of an error that triggers erasure when consuming a cultivated state in a quantum algorithm.

Results of magic state proxy simulations

Our discussions in Section III B 3 and Section IV A predict that the logical error rates of our example concatenated cultivation circuits should scale as $O(p^{\min\{4,t+2\}})$. We therefore expect our distance-4 examples ($[[36,4,4]]$ and $[[48,8,4]]$) to scale as $O(p^3)$, and the distance-6 example ($[[96,14,6]]$) to achieve the full $O(p^4)$ suppression provided by the cultivation protocol. The results of our proxy simulations, shown in Figure 6, support this prediction.

In the first eight columns of Table I (PDF p. 11) we report metrics for the simulated circuits along with the logical error and discard rates at a physical error rate of $p=5\times10^{-4}$. We emphasize that there are clear avenues to improve the spacetime overheads of these circuits. Firstly, the total qubit count is an overly conservative estimate here; from Figure 3 we see that 25% of the physical qubits in the level-1 $[[6,2,2]]$ code blocks are ancillas. These ancillas can be reused later on in the encoding circuit but this is not done currently. As another example, the $\ell=1$ and $\ell=2$ stabilizer measurements are performed serially as shown in Figure 11. More careful optimization of the sub components of Figure 5 would no doubt increase performance.

Code	Qubits	CNOTs	Depth	Meas.	Discard rate	Error rate $p_L$ (95% CI)	spacetime cost $C$	$p_L^{\mathrm{SC}}$	spacetime cost $C_{\mathrm{SC}}$
$[\![36,4,4]\!]$	112	880	73	272	41.3%	$8.29^{+0.64}_{-0.60} \times10^{-9}$	$1.39 \times10^4$	$2.07^{+0.16}_{-0.15} \times10^{-9}$	$1.61 \times10^5$
$[\![48,8,4]\!]$	144	1172	74	356	50.7%	$2.21^{+0.15}_{-0.14} \times10^{-8}$	$2.16 \times10^4$	$2.76^{+0.19}_{-0.18} \times10^{-9}$	$3.20 \times10^5$
$[\![96,14,6]\!]$	256	3142	164	854	86.7%	$1.14^{+0.20}_{-0.17} \times10^{-10}$	$3.16 \times10^5$	$8.14^{+1.45}_{-1.23} \times10^{-12}$	$> 5.98 \times10^5$

One way to contextualize the performance of concatenated cultivation (Table I (PDF p. 11) and Figure 6) is to compare with magic state cultivation in the surface code [32]. Specifically, we focus on the spacetime cost for producing a magic state at given logical error rate. There is a subtlety in the comparison as our method is batched, while cultivation on the surface code allows individual magic states to be produced sequentially. A given instance of our protocol produces $\lvert H\rangle^{\otimes K}$ with logical error rate $p_L$ and naive spacetime cost $C=\frac{\text{qubits}\mathbin{\circ}\text{depth}}{1-\text{discard rate}}$. We compare $C$ with the spacetime cost $C_{\mathrm{SC}}$ of producing $\lvert H\rangle^{\otimes K}$ with logical error rate $p_L$ via surface code cultivation. To estimate $C_{\mathrm{SC}}$, we find the spacetime cost $C_{\mathrm{SC}}^{(0)}$ of cultivating a state with logical error rate $p_L^{\mathrm{SC}}=1-(1-p_L)^{1/K}$ and set $C_{\mathrm{SC}}=K C_{\mathrm{SC}}^{(0)}$.

Using the noise model described in Section IV A we simulate surface code cultivation at $p=5\times10^{-4}$ and toggle the complementary gap to achieve the target single-qubit error rate $p_L^{\mathrm{SC}}$, which gives a value for $C_{\mathrm{SC}}^{(0)}$. Our simulations consist of performing two rounds of cultivation at $d=3$ and $d=5$ and then embedding the $d=5$ code into the $d=11$ surface code. Ref. [32] reports spacetime cost in qubit $\circ$ rounds where each round roughly corresponds to a depth-10 circuit. We note that the estimate of this cost incorporates that not all qubits in the final $d=11$ patch are used throughout the circuit, which is not done for the concatenated cultivation circuits. Thus the comparison of the spacetime cost should be understood to be generous to the surface code cultivation circuit.

In the final three columns of Table I (PDF p. 11) we report the spacetime cost $C$, the corresponding surface-code-cultivated logical error rate $p_L^{\mathrm{SC}}$ and the spacetime cost $C_{\mathrm{SC}}$. In the case of code $[[96,14,6]]$, a logical error rate of $p_L^{\mathrm{SC}}\sim10^{-12}$ is not achievable and likely requires an additional level of cultivation at $d=7$. In place, of this we used the minimal value of $p_L^{\mathrm{SC}}=3.6\times10^{-11}$ obtained by cultivation at $d=5$ in Table I (PDF p. 11), and simply note that the reported value for $C_{\mathrm{SC}}$ is a significant underestimate. Nevertheless, in all cases the associated spacetime cost for cultivation $C_{\mathrm{SC}}$ is more than one order of magnitude larger than the cost $C$ of the corresponding concatenated protocol.

CSS resource states for Clifford gates

In this section, we report benchmarks for fault-tolerantly preparing the CSS states need to perform logical Clifford gates via injection. Recall from Theorem 1 that the resource states for $S/H$-type gates are tensor products of logical $\lvert0\rangle$ and $\lvert+\rangle$ states on a single $[[N,K,D]]$ block. The representative $S/H$-type resource states that we compile for our benchmarks correspond to the logical gates

$CX$-type resource states are injected via Knill-QEC teleportation and require two $[\![N,K,D]\!]$ blocks, as indicated in Figure 1(e). For the $CX$ gate injection, we benchmark $CX$-type resource states for circuits with 9, 30, and 74 logical $CX$ gates, respectively, for codes $[\![36,4,4]\!]$, $[\![48,8,4]\!]$ and $[\![96,14,6]\!]$. The logical $CX$ circuit for code $[\![48,8,4]\!]$ is shown in Figure 7, and the remaining circuits are provided in Figure 13.

!Logical circuit implemented by the CX-type resource state benchmarked for code [48, 8, 4] bbox=0.09,0.25,0.50,0.42

!Three CX-type gate circuits for codes [36, 4, 4], [48, 8, 4] and [96, 14, 6] bbox=0.08,0.07,0.85,0.44

All Clifford resource-state circuits are obtained using the flag-at-origin method in Ref. [20], which we also briefly describe in Appendix D 1. We additionally perform a search over 1000 randomly sampled bipartite graph states that are equivalent to the CSS state that we want to prepare. Flag-at-origin adds the flag gadgets to each of of these circuits and selects the one that presents the smallest total probability of a physical fault across the fault locations in the resulting circuit. For each resource state, we prepare two encoding circuits that respectively minimize either qubit count (space) and circuit depth (time). Below, we omit the data for the space-optimized circuit for code $[\![96,14,6]\!]$ because the discard rate was nearly 100% for values of $p \ge5 \times10^{-4}$.

Figure 8 shows that the circuits minimizing depth outperform those minimizing space both in logical error rate and discard rate. This is expected due to inclusion of idling error in our noise model. We find that the trade-offs between space and time contribute unequally to the overall spacetime volume, with the depth-optimized circuits having much smaller spacetime volume than the space-optimized circuits.

As discussed in Section II, the alternative method for producing resource states for Clifford gates, distillation, has the drawback that the minimum factory size for producing a single copy of a resource state is large: $n(d+1)^2$. This was one of our primary motivations for employing the flag-at-origin method, which achieves the same fault distance but has a significantly smaller minimum factory size. The qubit requirements for both methods are reported in Table II.

Circuit	Distillation factory size (qubits) [18]	Qubits	Depth	CNOTs	Meas	Discard Rate	Error Rate $p_L$ (95% CI)
$[36,4,4]_{\mathrm{CNOT\_time}}$	3600	264	48	700	192	37.93%	$4.92^{+0.18}_{-0.17} \times10^{-7}$
$[36,4,4]_{\mathrm{CNOT\_space}}$	3600	130	569	700	192	47.78%	$3.92^{+0.05}_{-0.05} \times10^{-6}$
$[48,8,4]_{\mathrm{CNOT\_time}}$	4800	378	64	1046	282	51.50%	$2.41^{+0.04}_{-0.04} \times10^{-6}$
$[48,8,4]_{\mathrm{CNOT\_space}}$	4800	180	811	1022	274	65.27%	$1.83^{+0.01}_{-0.01} \times10^{-5}$
$[96,14,6]_{\mathrm{CNOT\_time}}$	17640	1415	186	3985	1235	96.19%	$9.01^{+0.57}_{-0.53} \times10^{-7}$
$[36,4,4]_{\mathrm{SH\_time}}$	900	120	26	282	84	17.50%	$4.79^{+0.35}_{-0.32} \times10^{-7}$
$[36,4,4]_{\mathrm{SH\_space}}$	900	65	244	282	84	20.23%	$9.83^{+0.50}_{-0.47} \times10^{-7}$
$[48,8,4]_{\mathrm{SH\_time}}$	1200	148	28	344	100	20.69%	$2.48^{+0.26}_{-0.23} \times10^{-7}$
$[48,8,4]_{\mathrm{SH\_space}}$	1200	77	292	348	102	24.66%	$2.23^{+0.07}_{-0.07} \times10^{-6}$
$[96,14,6]_{\mathrm{SH\_time}}$	4410	495	91	1266	405	62.05%	$6.90^{+0.81}_{-0.72} \times10^{-8}$
$[96,14,6]_{\mathrm{SH\_space}}$	4410	169	802	994	264	62.07%	$1.31^{+0.08}_{-0.08} \times10^{-6}$

We leave a more granular analysis of the overheads for specific codes and error models—factoring in spacetime cost and acceptance rates—for future work. While flag-at-origin circuits achieve the expected scaling of logical error rate, we note that the values of $p_L$ are at least an order of magnitude worse than their counterparts for the proxy magic state distillation in Section IV B 2. This discrepancy suggests that there may be better methods for fault tolerant preparation of CSS states in these codes that leverage the iterative structure of concatenation. Indeed, flag-at-origin is an algorithmic method for producing fault tolerant circuits that prepare arbitrary CSS states but it makes no claims about optimality.

Discussion

We have presented a scheme for universal fault-tolerant quantum computation in which almost every logical gate is injected via teleportation, consuming fault-tolerantly prepared resource states. Arbitrary multi-qubit Clifford circuits require at most 9 CSS resource states, and a universal gate set is completed by consuming logical magic states. As a by-product, injecting these resource states yields full (Knill) or partial (Steane) syndrome measurements, reducing the need for additional gadgets used purely for syndrome extraction. Our scheme is restricted to the family of concatenated codes built from SWEL seed codes because it is precisely for this family that both classes of resource state can be prepared with high

fidelity and low overhead. The transversal global $H^{\otimes k}$ and $S^{\otimes k}$ gates allow us to reduce every Clifford to CSS resource states preparable by flag-at-origin, and enables the concatenated cultivation protocol.

The numerical results in this paper provide an initial benchmarking of the quality of the CSS and magic state resource states. This is a necessary first step, but it is deliberately local in scope: we have characterized the cost per resource state rather than the cost of a computation. Our results suggest that logical circuits in the megaquop and gigaquop regimes are executable on codes and at physical error rates that near term hardware can accommodate, but a study with a more global view is a natural next step. Concretely, one would like end-to-end estimates of the cost of executing a Bruhat-decomposed Clifford circuit—accounting for the $O(1)$ injections per stage and the online rejection incurred at each injection—as well as the cost of synthesizing single-qubit rotations to a target precision $\epsilon$, where the $T$-count and hence the number of $|H\rangle^{\otimes k}$ states scales as $O(\log(1/\epsilon))$. Combining our per-state benchmarks with a suitable compiler would yield spacetime-cost estimates for complete algorithms and allow a fair comparison against other high-rate computing architectures. We provide further discussion about compilation, including a scheme to minimize latency in $T$-gate layers and a scheduler to minimize the $T$-depth of a circuit, in Appendix E.

As mentioned in Section IV, there are clear pathways to improving the resource state preparation circuits. When scaling up these codes, both by increasing the size of the seed codes and the level $L$ of concatenation, the lookup tables used for decoding in this work will not be viable. In this case algorithmic decoders that incorporate concatenation structure can be used to achieve good performance [9]. On another note, in this work we have imposed homogeneity between the code blocks containing data qubits and code blocks storing resource states, but relaxing this distinction should decrease overheads and flexibility of compilation. For this to be possible, there needs to be compatible structure existing between the data block and the ancilla block, such as a homomorphic logical CNOT [36]. In this case, gate injections for certain resource states can in principle be performed. For concatenated codes, computationally tractable searches for these homomorphic logical CNOT can be carried out on seed codes and then chained together to yield fault tolerant inter-block logical CNOT gates for large distance codes.

Acknowledgments

We acknowledge helpful correspondence with Shival Dasu and Hayato Goto. We thank Ruslan Shaydulin and Rob Otter for executive support of this work.

References

but at least one logical Pauli-$X$ operator with support on an odd number of physical qubits [12].

Concatenated H codes

Here we present some further exploration of concatenated cultivation with $[[k+4,k,2]]$ H codes [23, 33]. As discussed in the main text, the encoding circuit of the full concatenated code $[[N,K,D]]$ relies on recursive use of FT encoders of the seed codes. Fortunately, encoding circuits for the H codes have a simple structure. At the input to the H code encoding circuits, we choose the physical qubits in $[0,k-1]$ to contain the logical information, and the pairs $[k,k+1]$ (initialized in $|++\rangle$) & $[k-2,k-3]$ (initialized in $|00\rangle$) to evolve to $X$ & $Z$ stabilizers. Using the format $CX\ [c_0,t_0]\ [c_1,t_1]\ldots$ to represent a sequence of $CX$ gates between control ($c_j$) and target ($t_j$) qubits, the encoding circuit is

$CX\ [k,k+3]\ [k+1,k+2]$

$CX\ [k+1,2q]\ [k+2,2q+1]\ [2q,k]\ [2q+1,k+3]$ (repeat over pairs $[2q,2q+1]$ with $q<k/2$).

$CX\ [k,k+1]\ [k+3,k+2]$

We provide example circuits in Figure 3 and Figure 9.

!Examples of H code encoders: (a) [[8, 4, 2]] encoder and (b) [[10, 6, 2]] encoder bbox=0.16,0.07,0.84,0.25

A nice property of this encoding circuit is that it satisfies Condition 1 without needing additional flag gadgets (unlike the $[[15,1,3]]$ Hamming example in Figure 4). We prepare the concatenated cultivation circuits for self-concatenated H codes at level-2, $[[(k+4)^2,k^2,4]]$ for $k\in[2,4,6,\ldots,16]$, by porting these encoding circuits into Figure 5. The benchmarking results are shown in Figure 10, where in addition to logical error rates and discard rates we plot the spacetime cost per $|H\rangle$ state at $p=5\times10^{-4}$. This quantity is given by (qubit number of encoder)$\times$(encoder depth)/(acceptance rate $\times k$) and is a rough proxy for the quantum resources involved to produce one fault tolerant magic state. Note this quantity is normalized by the number of logical qubits per block, so Figure 10 points to the $[[64,16,4]]$ code being most efficient for creating magic states at $p=5\times10^{-4}$.

Fault tolerant circuits for magic states

Here we provide more details on some of the subcircuits and flag gadgets used the concatenated cultivation circuits. The protocol is shown schematically in Figure 5.

Flag gadgets for individual undetectable faults

Concatenated cultivation relies on encoding circuits that posses no individual Pauli faults violating Condition 1. Here we describe two types of gadgets that we use to modify generic encoding circuits to catch the problematic errors that violate Condition 1.

Our strategy for producing suitable encoding circuits is as follows. We first use the Munich Quantum Toolkit (MQT) [34] to produce a general encoding circuit. We then enumerate all individual faults that are equivalent to pure-logical errors and violate Condition 1, identify those faults that are caught by the “simple” $X/Z$ flag gadgets described in Section C 1 a, and add the corresponding flag gadgets to the circuit accordingly. Finally, we identify a minimal set of logical Pauli operators that anti-commute with the remaining problematic errors, and sandwich the encoding circuit with corresponding spacetime flags described Section C 1 b.

Simple X/Z flag gadgets

The basic idea for the simple $X/Z$ flag gadgets is to first identify “star”-type subcircuits of $CX$ gates, which have a shared “central” qubit as either the control or the target of all $CX$ gates. These subcircuits are compatible with gadgets to catch any multi-qubit Pauli error that, when propagated to the end of the subcircuit, addresses the central qubit by an $X$ or $Z$ error (for the $X$ and $Z$ gadgets, respectively). Specifically, the $X$ and $Z$ flag gadgets are, respectively,

Spacetime gadgets

Suppose a single fault in an encoding circuit generates a pure logical error that anti-commutes with a logical Pauli $P$ on logical qubit $q$, denoted $\bar{P}_q$. We can catch this fault by entangling physical qubit $q$ with an ancilla before running the encoding circuit, and then disentangling logical qubit $q$ the ancilla after the running the decoding circuit [37]. In the case of $q = 0$, this gadget looks like

Additional circuits

Here we include some additional circuits used in our protocol. We use the measurement circuit in Figure 11 for the $\ell= 1$ stabilizers. The $\ell= 2$ stabilizer measurements are also measured in this serial fashion. As mentioned in Section III, we make no effort to optimize these circuits or to identify smaller subsets of the stabilizers sufficient to catch logical errors. When encoding $C_1$ code blocks into the $C_2$ code, “ancilla” $C_1$ code blocks whose logical Pauli operators get mapped to stabilizers of $C_2$ are encoding using the circuit in Figure 12, rather than the general encoding circuit in Figure 3.

!Encoding circuit for the $|00\rangle$ state of the $[[6,2,2]]$ H code bbox=0.30,0.07,0.70,0.32

CSS states

This appendix is a supplement to Section II.

Flag at origin

Fault-tolerant preparation of logical states is a prerequisite for fault-tolerant quantum computation. In order to leverage the distance $d$ of a code, the preparation circuits of logical states of that code must have circuit fault distance of $d$. This means ensuring that any combination of $f \le t = \lfloor(D-1)/2\rfloor$ faults that propagates to an error of minimum weight $w \le f$ up to stabilizers is detectable. Prior approaches are limited by poor scalability (flag-based methods) or high overhead from repeated verification rounds. In the case of CSS states, which is all that is required to perform Clifford gates in our protocol, the flag-at-origin protocol [20] provides a modular, single-shot construction.

The protocol exploits a structural property of CSS state-preparation circuits: any CSS state can be prepared using a bipartite $CX$ circuit in which qubits are partitioned into sets $A$ and $B$, with all $CX$ directed from $A$ (controls) to $B$ (targets). For circuits with this bipartite structure $X$ and $Z$ errors can be handled separately:

• $X$-type errors propagate forward: an $X$ fault on a control qubit spreads $X$ errors onto target qubits in subsequent layers.

• $Z$-type errors propagate backward: a $Z$ fault on a target qubit effectively infects earlier control qubits.

The key idea is to place flag gadgets at the origin of each propagation direction—catching errors before they spread out into high-weight, uncorrectable configurations.

CX gates

Here we show the exact logical circuits implemented by consuming the $CX$ states prepared in codes [[36, 4, 4]], [[48,8,4]] and [[96,14,6]]. For each code we randomly generated a sequence of $\sim K^2/\log^2 K$ $CX$ gates on $K$ qubits. Specifically, these circuits consist of 9, 30 and 74 logical $CX$ gates for codes [[36, 4, 4]], [[48,8,4]] and [[96,14,6]]; see Figure 13. The stabilizers of the corresponding resource state are obtained by preparing two code blocks into $K$ logical Bell pairs, and applying the $CX$ circuit to one of the code blocks, as in the boxed subcircuit for $|\Phi,U\rangle$ in Eq. (1).

Loose ends

Feedforward gates

The main compilation bottleneck for our protocol is the Clifford correction required after a $T$ injection. This is common to all magic-state protocols but is exacerbated by the high rate of our code blocks: the measurement outcomes $s \in\mathbb{Z}_2^k$ in Eq. (7) call for an addressable correction $S^{\otimes s}$, and because $s$ is known only at runtime the corresponding resource state cannot be prepared in advance, while the $2^k$ possible outcomes rule out precompiling them all. One option is simply to absorb this latency, consuming prepared Knill/Steane-QEC resource states—and running a dedicated factory of logical Bell states for Knill-QEC error correction—while the $S$ resource state is made.

To limit this latency one could attempt to precompile as much of the $S$ resource state ahead of time as possible. One way to attack this is to prepare an $s$-independent reference state offline, say $\lvert0\rangle^{\otimes k}$, and shape it at runtime. First, note that having a free global $S^{\otimes k}$ and free logical Pauli-$Z$ strings means we only need to address at most $\lfloor k/2\rfloor$ qubits: if $s \in\{0,1\}^{k}$ is a bitstring and $\bar{s}$ is its bitwise complement, then we can freely convert an $S$ gate on the $|s|$ qubits indicated by $s$ into an $S$ gate on the $|\bar{s}|=k-|s|$ qubits indicated by $\bar{s}$:

To produce the required state $H^{\otimes s}|0\rangle$ we start from the reference state $|0\rangle^{\otimes k}$ and convert $|0\rangle\rightarrow|+\rangle$ on the addressed qubits by measuring the corresponding logical $\bar{X}_i$ operators, applying a $\bar{Z}_i$ correction on the $-1$ outcome. A Steane-style measurement would be single-shot but circular—it requires an ancilla in exactly the state $H^{\otimes s}|0\rangle$ we are trying to make—so we can instead perform a Shor-style measurement of each $\bar{X}_i$ with a cat-state ancilla, verified by post-selected $ZZ$-parity checks. For each addressed operator the first measurement is the (random) projective state preparation, and the remaining rounds merely confirm its outcome against readout faults; discarding on any disagreement, $\lceil(d+1)/2\rceil$ rounds suffice for fault distance $d$ (one projection plus $\lfloor(d-1)/2\rfloor$ confirmations). Each round of logical measurements needs to be followed by a QEC round for the $X$-sector, which can be performed in $O(1)$ depth using an ancillary $|+\rangle$ state that can be prepared in advance.

We can tally the space and online time cost of preparing the $S$ resource state via precompilation under the assumption that the $\lfloor k/2\rfloor\lceil(d+1)/2\rceil$ verified cat states, $\lceil(d+1)/2\rceil$ $|+\rangle^{\otimes k}$ states and the $|0\rangle^{\otimes k}$ state are prepared in advanced and available on demand. The depth of each logical measurement round can be upper bounded by $\lfloor k/2\rfloor$. In this case the conversion from $|0\rangle^{\otimes k}\rightarrow H^{\otimes s}|0\rangle^{\otimes k}$ is depth $\lfloor k/2\rfloor\lceil(d+1)/2\rceil+\lceil(d+1)/2\rceil$. To tally the space cost we first note that without additional optimization the cat states use $|X|=\max(|X_i|)_{i\leq k}+1$ qubits, where $|X_i|$ is the Hamming weight of a representative of the $i$-th $X$ logical operator. Let $C$ be the cat qubit cost for making $|+\rangle^{\otimes k}$ or $|0\rangle^{\otimes k}$. Then creating the $S$ resource state via conversion costs $\lfloor k/2\rfloor\lceil(d+1)/2\rceil|X|+(\lceil(d+1)/2\rceil+1)C$. If we use flag-at-origin for the no-precompilation strategy we can compare the $S/H$ depth results in Table II to an upper bound for the online depth with the precompilation strategy, $\lfloor k/2\rfloor\lceil(d+1)/2\rceil+\lceil(d+1)/2\rceil$. Comparisons of qubit cost are murkier because both flag-at-origin and concatenated cultivation can be used to produce the $\lvert+\rangle^{\otimes k}$ and $\lvert0\rangle^{\otimes k}$ states. Tables I and II provide estimates for the qubit costs $C$ of these approaches, though in cultivation case of Table I, the qubit (along with depth and rejection rate) numbers are large over-estimates because the injection circuits contain a lot of machinery for measuring logical $H$ operators in Figure 5 (such as logical $T_Y$ gate injections) that is not necessary to prepare $\lvert+\rangle^{\otimes k}$ and $\lvert0\rangle^{\otimes k}$ states. Table III shows the ratios of online depth and qubit cost for precompilation using concatenated cultivation (with the aforementioned overheads eliminated; replacing Table I) versus time-optimized flag-at-origin circuits (identical to Table II).

For the precompiled approach the reduction in online depth is roughly commensurate with the increase in qubit cost. Here qubit cost only accounts for the minimum number of qubits needed to prepare the $S$ resource state and idling of the data qubits during this preparation necessitates a number of QEC cycles – and therefore Knill/Steane resource states – extensive in the wait time. The upshot is that the precompilation strategy likely also has reduced qubit overhead when one looks at the total cost of implementing the $T$ gate fault-tolerantly. It should be emphasized that this comparison is somewhat simplistic in that it does not incorporate the rejection rates of the ancilla states, which need to be factored in to estimate the expected qubit cost of minimizing data qubit idling. At the level of the state preparation circuits themselves, methods from Ref. [9] point to there being less costly ways to prepare $\lvert0\rangle^{\otimes k}$ and $\lvert+\rangle^{\otimes k}$ states in concatenated codes. We leave optimizing the compilation of $T$ gate layers in these codes to future work.

Compilation and scheduling

Here we briefly discuss the compilation of circuits into the primitives defined in Section II and Section III. To this end, we first decompose any quantum circuit into a Clifford+$T$ gate set. We then repeatedly sift the circuit for $T$ gates using the sifting procedure of Ref. [38 Algorithm 1]. For a fixed Clifford+$T$ circuit $C$, sifting for $T$ gates partitions $C$ into three sub-circuits, $(C_{\mathrm{before}}, C_T, C_{\mathrm{after}})$ with the following guarantees:

1. Applying the sub-circuits in sequence recovers the original circuit, $C = C_{\mathrm{after}} C_T C_{\mathrm{before}}$.

2. $C_{\mathrm{before}}$ consists of only Clifford gates.

3. $C_T$ consists of only disjoint single-qubit $T$ gates.

4. No gate from $C_{\mathrm{after}}$ can be moved into $C_T$ or $C_{\mathrm{before}}$ without violating the guarantees above.

In a nutshell, sifting iterates over every gate in $C$ (in any valid time-ordering of the gates), and greedily adds each gate to the earliest of $(C_{\mathrm{before}}, C_T, C_{\mathrm{after}})$ possible without violating the partial time-ordering of gates [39]. Recursively sifting the trailing circuits $C_{\mathrm{after}}$ for $T$ gates yields a $T$-depth-optimal schedule for the gates in $C$. Every $T$-layer can then be applied with one $T$-gate injection, while the Clifford layers in between can be resynthesized and injected according to the prescription in Section II.

TABLE III. Ratio metrics for precompilation versus no-precompilation. We use concatenated cultivation for precompilation circuits and remove the excess qubits associated with injections that are only needed for $\lvert H\rangle$ states. Logical operators in Appendix § 2.1.1 provide conservative estimates of $\lvert X\rvert= 10$, 10, and 16 qubits for the $\llbracket36,4,4\rrbracket$, $\llbracket48,8,4\rrbracket$, and $\llbracket96,14,6\rrbracket$ cat states.

Code	Online depth ratio	Qubit cost ratio
$\llbracket36,4,4\rrbracket$	0.346	2.767
$\llbracket48,8,4\rrbracket$	0.536	3.081
$\llbracket96,14,6\rrbracket$	0.352	2.319

Disclaimer

This paper was prepared for informational purposes with contributions from the Global Technology Applied Research center of JPMorgan Chase & Co. This paper is not a product of the Research Department of JPMorgan Chase & Co. or its affiliates. Neither JPMorgan Chase & Co. nor any of its affiliates makes any explicit or implied representation or warranty and none of them accept any liability in connection with this paper, including, without limitation, with respect to the completeness, accuracy, or reliability of the information contained herein and the potential legal, compliance, tax, or accounting effects thereof. This document is not intended as investment research or investment advice, or as a recommendation, offer, or solicitation for the purchase or sale of any security, financial instrument, financial product or service, or to be used in any way for evaluating the merits of participating in any transaction.