High-fidelity and Fault-tolerant Teleportation of a Logical Qubit using Transversal Gates and Lattice Surgery on a Trapped-ion Quantum Computer
C. Ryan-Anderson N. C. Brown C. H. Baldwin J. M. Dreiling C. Foltz J. P. Gaebler T. M. Gatterman N. Hewitt C. Holliman C. V. Horst J. Johansen D. Lucchetti T. Mengle M. Matheny Y. Matsuoka K. Mayer M. Mills S. A. Moses B. Neyenhuis J. Pino P. Siegfried R. P. Stutz J. Walker D. Hayes





ciaran.ryan-anderson@quantinuum.com

natalie.brown@quantinuum.com






















Quantinuum, 303 South Technology Ct., Broomfield, CO 80021, USA




Quantum state teleportation is commonly used in designs for large-scale fault-tolerant quantum computers. Using Quantinuum's H2 trapped-ion quantum processor, we implement the first demonstration of a fault-tolerant state teleportation circuit for a quantum error correction code - in particular, the planar topological [[7,1,3]] color code, or Steane code. The circuits use up to 30 trapped ions at the physical layer qubits and employ real-time quantum error correction - decoding mid-circuit measurement of syndromes and implementing corrections during the protocol. We conduct experiments on several variations of logical teleportation circuits using both transversal gates and lattice surgery protocols. Among the many measurements we report on, we measure the logical process fidelity of the transversal teleportation circuit to be 0.975±0.002 and the logical process fidelity of the lattice surgery teleportation circuit to be 0.851±0.009. Additionally, we run a teleportation circuit that is equivalent to Knill-style quantum error correction and measure the process fidelity to be 0.989±0.002.

High-fidelity and Fault-tolerant Teleportation of a Logical Qubit using Transversal Gates and Lattice Surgery on a Trapped-ion Quantum Computer
    D. Hayes
    April 29, 2024
===============================================================================================================================================

empty 

The quantum teleportation protocol was first discovered by Bennett et al. <cit.> and was experimentally demonstrated shortly thereafter <cit.>. By pre-distributing an entangled pair of qubits to two registers, a third qubit can be teleported between the registers via transferring two bits of classical information. This protocol was immediately recognized as an enabler for quantum computing or quantum networks, where qubits need to interact in non-local geometries but moving them is challenging or slow. By distributing entangled pairs throughout a quantum computer, qubits can, in principle, be transmitted at the same speed as classical information. As it is strongly believed that fault tolerance will be needed for large quantum computations, it is ultimately at the logical level <cit.> where teleportation becomes truly enabling.

In this work, we demonstrate the maturity of the H-series trapped-ion quantum processors by performing the first fault-tolerant version of the state teleportation circuit using a quantum error correction (QEC) code (i.e., a quantum code with distance of three or greater). We demonstrate four logical variants of the teleportation protocol using up to 30 trapped-ion qubits and real-time QEC and contrast the results with the teleportation of physical qubits. Two of the logical variants use lattice surgery to implement logical gates, which, to the best of our knowledge, are the first demonstrations of lattice surgery performed on a QEC code. 
These experiments used Quantinuum's H2 trapped-ion quantum processor <cit.>, which currently operates with 32 physical qubits. We give more hardware details throughout the text and in Appendix <ref>.




§ EXPERIMENTAL DESIGNS

In the teleportation protocol, the task is to send a state |ψ⟩ from one qubit register to another. We refer to the qubit initially encoding |ψ⟩ as qubit one. To begin, an entangled Bell-pair, (|00⟩+|11⟩)/√(2), is created as a quantum resource state to facilitate the protocol, and we refer to these qubits as qubits two and three (see Fig. <ref>). In the next step, a joint measurement of qubits one and two is made by first entangling them and then performing individual measurements on them, effectively measuring X ⊗ X and Z ⊗ Z. This measurement “disassembles” |ψ⟩
and yields two bits of classical information. The joint measurement (or Bell measurement) reveals no local information about |ψ⟩, preventing a wave-function collapse, and only reveals global information about the bit and phase parities between the measured qubits. The two bits of classical information are then used to choose appropriate single qubit operations to reassemble |ψ⟩ in the unmeasured qubit three. So the state of qubit one is teleported into qubit three via the transfer of two classical bits.

This section describes the three distinct groups of teleportation experiments we performed: (1) a physical-level protocol, (2) a logical-level protocol using transversal gates, and (3) a logical-level protocol using lattice surgery gates.




 §.§ Physical-level Experiment

We establish a performance baseline by first characterizing the teleportation protocol implemented at the physical level. To do so, we constructed circuits consisting of four independent teleportation circuits running in parallel. Four copies were run to average the performance across the four gating and measurement zones in the H2 trap <cit.>; therefore, the physical teleportation circuits used 12 qubits.

The teleportation circuit was benchmarked by sending an informationally complete set of states through the circuit and measuring the probability of finding the correct state at the output. The six eigenstates of the single-qubit Pauli operators were used as inputs: |ψ⟩∈{|0⟩,|1⟩,|+⟩,|-⟩,|+i⟩,|-i⟩}. 
The average state fidelity of the teleportation over this set is F_a = 16∑_ψ p_ψ, where p_ψ is the probability of finding the correct state as the output. This quantity determines the process fidelity using F_p = ((d+1) F_a - 1)/d <cit.>, where, the dimension, d=2 for teleportation of a single qubit. Note, this method of fidelity estimation does not distinguish different sources of error (e.g., SPAM versus gate and memory errors). In this work, we are focused on the different teleportation protocols studied and their overall fidelity. We leave it to future work to analyze component-level performance on the physical and logical level <cit.>.

We measure the process fidelity of the physical-level experiment to be 0.9895^+3_-3, with details in Fig. <ref> and Tables <ref>,<ref>. We note that the state fidelities of the physical-level experiment are lower for the -1 eigenstates compared to the +1 states. This could be due to a known bias of the device at the physical level in measuring |0⟩ with slightly higher fidelity than |1⟩ <cit.>, but a careful investigation is beyond the scope of this work.










 §.§ Logical-level Experiments: Transversal Circuits





This section describes two equivalent logical teleportation protocols composed entirely of transversal gates.
In benchmarking transversal logical operations, a natural question arises – whether or not to include QEC gadgets[Here, we define QEC gadgets as the fault-tolerant measurement of syndromes (which perform an identity operation on the logical information), but have sufficient information to infer and correct faults.]. 
It is not entirely uncommon to hear claims in the emerging field of experimental QEC that transversal circuits do not require QEC gadgets to achieve fault tolerance, but in the context of large-scale, real-world devices, this claim is oversimplified and deserves further nuance. 

The claim stems from technical definitions of fault-tolerance <cit.> and a requirement that circuit components not allow a single fault to spread into multiple faults. Transversal gates trivially satisfy this property. Since two composed transversal operations can generate another transversal operation, one might conclude there is no limit to how large a transversal circuit can be, maintaining fault tolerance without using QEC gadgets. 
However, simple probabilistic noise accumulation in a series of transversal operations will eventually overwhelm any code and introduce logical errors, setting a natural limit to the number of transversal operations that can be done without QEC gadgets.
The situation is compounded when the logical circuit connectivity becomes more complex, as this can lead to faults cascading so that what was originally a correctable fault becomes uncorrectable.

When a quantum computer's transversal operations have error rates above or near the threshold, we suggest it is prudent for benchmarking experiments to include QEC gadgets. Our logical CNOTs operate near the pseudo-threshold (our physical CNOT error is 𝒪(10^-3)). We include QEC gadgets in some of these circuits and look at circuits without QEC gadgets to gain information about the logical error budget. 

The teleportation circuit utilizing transversal CNOTs is illustrated in  Fig. <ref>.
The circuit is encoded with the [[7,1,3]] QEC code, or Steane code  <cit.>, which has been used in many demonstrations of logically encoded circuits  <cit.>, including our previous work  <cit.>. Refs. <cit.> detail all the techniques and subroutines relevant to this section, and here we provide a brief overview of them.

The logical-level teleportation circuit is analogous to the physical-level circuit.
What is different is the underlying physical implementation necessary for encoding and performing quantum error correction. 
First, logical qubits two and three are prepared in |0⟩_L using a fault-tolerant encoding circuit, which includes a single non-destructive logical Z measurement per logical qubit to verify proper preparation of the state (we use the L subscript for logical states and overlines for logical operators)  <cit.>. Transversal Hadamard and CNOT gates are then applied to qubits two and three to create the Bell-pair  <cit.>.
Then, qubits two and three undergo a simple round of syndrome extraction using flagged circuitry <cit.>, measuring each of the six syndromes once.
As illustrated in Fig. <ref>, the syndrome extraction gadgets implemented on qubits two and three occur before either of those qubits interact with the qubit initially storing |ψ⟩_L; therefore, the syndrome extraction gadgets are considered part of the resource Bell-state preparation.

We take advantage of the resource state construction by noting that, in large-scale fault-tolerant architectures, it is scalable to use post-selection to create resource states such as magic states or Bell pairs. Such architectures assume large devices will have capacity to prepare resource states ahead of time and in parallel, allowing well-prepared resource states to be available for the computation when they are needed <cit.>. In this work, well-prepared Bell states are post-selected using both the verification measurement in the encoding circuit and the syndrome measurements after the entangling operation. The scheme does not eliminate all errors from the Bell pair; for example, a weight-three fault resulting in a logical operator being applied would go undetected. 

Note, this logical Bell resource-state preparation method was first developed for this work for use in the logical teleportation protocols and was then analyzed as an individual component in Ref. <cit.>. A description of the performance of this logical Bell state preparation component can be found in the reference.

After the Bell state is prepared, logical qubit one is initialized to |0⟩_L using the encoding circuit <cit.>. In contrast to the preparation of the Bell-state resource, the encoding circuit for logical qubit one uses up to three rounds of a repeat-until-success protocol <cit.>, at which point the circuit proceeds regardless of the outcome of the verification step. That is, we do not post-select on the preparation of logical qubit one. After preparing |0⟩_L, a transversal single-qubit Clifford operation, natively admitted by the Steane code, can prepare one of the six states, {|0⟩_L,|1⟩_L,|+⟩_L,|-⟩_L,|+i⟩_L,|-i⟩_L}.

We implemented two variants of the logical circuit depicted in Fig. <ref>. These variants differ only by the presence/absence of a full QEC gadget on logical qubit one. 
Given the importance of QEC gadgets in large-scale fault-tolerant computation, we consider the benchmarking with the QEC gadget included as important. However, examining the circuit without the QEC gadget offers insight into the logical error contributions of the teleportation protocol. Note, we call the protocol that includes one QEC gadget on logical qubit one as “1QEC” and the protocol without the QEC gadget as “0QEC.” Interestingly, the entire 0QEC experiment can be viewed as the implementing a QEC gadget as originally proposed by Knill <cit.>.

In the 1QEC experiment, the QEC gadget implemented is the full conditional adaptive syndrome extraction circuitry described in Ref. <cit.>. The extracted syndromes are processed in real-time using a look-up table decoder.
Active error correction is then applied, which involves physically applying Pauli corrections (instead of Pauli frame tracking).

Next, we perform the Bell measurement on qubits one and two.
All the data qubits in logical qubits one and two are measured destructively during the Bell measurement. These measurements are used to reconstruct syndrome information, decode, and correct the logical outcomes. 
The corrected outcomes are then used to update the Pauli frame of qubit three, equivalent to conditionally applying the classically controlled  Pauli gates on qubit three.

To measure the probability of finding the correct state in logical qubit three (i.e., determine the state fidelity), we apply a single-qubit transversal gate to measure in a particular basis, destructively measure all data qubits, reconstruct syndromes, decode, and apply corrections to the final logical outcome (see <cit.> for details).

For clarity, we emphasize that real-time decoding occurs four times in this circuit. During the QEC gadget and the three destructive logical measurements, the decoder measures syndromes and determines corrections.

We estimate the process fidelities of these circuits to be 0.975^+2_-2 when a QEC gadget is included on logical qubit one and 0.989^+1_-1) when the QEC gadget is omitted. This result suggests the QEC gadget is one of the noisier components of the circuit, consistent with previous measurements <cit.>. There was also a difference in the total number of physical qubits used in each experiment, with the included QEC gadget version using 30 physical qubits (10 for each code block) and the version without a QEC gadget requiring 28 (10 for each code block in the Bell state, and for the other code block, 7 data qubits and an additional verification ancilla for the encoding circuit).  

We further re-evaluated the data considering the framework of quantum error detection (QED). In this analysis, in addition to post-selecting on Bell-state preparation, we also post-select based on non-trivial syndrome information obtained from the QEC gadget and the outcomes of destructive logical measurements. This approach offers data for work studying QED distance-two codes to compare against the performance of QEC codes when viewed through the lens of QED. Moreover, this analysis sheds additional light on the underlying noise model by indicating the rate at which noise induces pure logical errors, which are undetectable and uncorrectable, during computation. Establishing an upper bound on performance, if error rates derived from re-assessing the data as a QEC code are notably high, this signals a potential need to revisit the experimental setup. When processing the data as a QED code, we find process fidelities of 0.9996_-5^+3 for 0QEC and 0.9998_-5^+2 for 1QEC. Further details are given in Fig. <ref> and Appendix <ref>.



 §.§ Logical Experiment: Lattice surgery







Transversal operations are not the only methods for performing logical gates. In this section, we demonstrate the flexibility of the quantum charge-coupled device (QCCD) architecture <cit.> by looking at equivalent logical teleportation circuits built from a color-code lattice-surgery gate set <cit.>.
Lattice surgery is a strategy for implementing logical gates that require only 2D nearest-neighbor interactions, making it especially useful for architectures whose qubit locations are fixed in a 2D space  <cit.>. 
The gate set of lattice surgery is made up of the joint measurements of logical Pauli operators. 
These joint operators are measured when merging code blocks together into a joint code block by measuring stabilizers between and within the original code blocks <cit.>. 
Unlike their transversal counterparts, lattice surgery protocols inherently require some form of syndrome measurements, with fault-tolerant implementation requiring a full QEC gadget. 
Since QEC gadgets are done with the logical gate implementation, direct comparisons with transversal gate sets are complicated.
Lattice surgery circuits have previously been demonstrated in ion-traps  <cit.> using d=2 quantum error detecting surface codes, and we build on this work by demonstrating these techniques on a d=3 quantum error-correcting color code.

An analogous logical teleportation circuit using lattice surgery techniques can be seen in Fig. <ref>. Some methods used here are identical to those used in the transversal circuits, such as the initialization protocols of all three logical qubits, transversal Hadamard gates, decoding, and destructive measurements.


The Bell-state preparation uses lattice-surgery gate sets.
After qubits two and three have been initialized, a joint X_2X_3 logical operator is measured (Fig. <ref> in appendix Sec. <ref>).
This measurement scheme includes an additional physical flag qubit to catch higher-weight hook errors  <cit.>. 
After the measurement of the joint logical operator, we perform one round of syndrome extraction using flagged checks (also used in the “Syn" gate in Fig. <ref>). 
We again treat the Bell state as a resource state and post-select on the same criteria as the transversal implementation (encoding verification failing and any non-trivial syndromes) and any non-trivial measurement from the flag qubit in the X_2X_3 joint logical measurement.
For this experiment, we only post-select on the Bell-state preparation. 
We decode the syndrome information in real-time, using the same decoder as the other experiments, and keep track of corrections on qubit three via a Pauli frame. 

The circuit proceeds by measuring a second joint logical operator Z_1Z_2, again using a flag circuit (Fig. <ref> in appendix Sec. <ref>). 
We then perform a full QEC gadget with both the flagged and conditional unflagged syndrome measurements. 
If the logical measurement flag or any syndromes in the QEC gadget are non-trivial, we repeat the measurement of Z_1Z_2, followed by the “Syn” gadget syndrome measurements (Fig. <ref>). 
We treat this second measurement round as ideal and continue with the circuit. 
If the first round of measurements of Z_1Z_2 and the full QEC gadget yield trivial flags and syndromes, the second round of measurements is skipped. 
The rest of the circuit involves transversal Hadamard gates, destructive measurements, decoding, and conditional corrections tracked via a Pauli frame, all of which are handled in the same way as in the transversal teleportation circuits. 

The lattice-surgery circuit, which we call M_XXM_ZZ, is measured to have a process fidelity of 0.851^+9_-9, and when further post-selected as a QED code, we find a process fidelity of 0.962^+5_-5, (details in Appendix <ref>). These QED process fidelities lag behind those of the transversal two-qubit gate QEC process fidelities, suggesting that enhancements in decoding strategies alone will not suffice for the lattice surgery protocols to achieve parity with the performance of the transversal protocols.
A total of 30 physical qubits were used in this experiment: 10 for each individual code block. 
The depth of the lattice surgery circuit is greater than that of its transversal counterpart, which likely contributes to the decreased fidelity. 


Lattice surgery offers more than an alternative way to implement logical gates, it can also reduce overheads in some cases  <cit.>. 
In this spirit, we also investigated an equivalent logical teleportation circuit using only two logical qubits instead of three. 
This version does not use a Bell state resource but can be shown to be algorithmically equivalent to teleportation protocol.
A “proof", showing the equivalency of this simpler circuit (Fig. <ref>(b)) to the typical teleportation circuit (Fig. <ref>), can be found in the Appendix <ref> (see Fig. <ref>). This form of lattice surgery teleportation can be seen as merging a logical qubit with an ancillary code block and then shrinking the newly created merged code block back to what was the auxiliary code block, transferring the logical state to the logical ancilla. The protocol itself can be viewed as a lattice surgery version of 1-bit teleportation <cit.>,
This technique can be used for various things, such as code-switching and gate teleportation  <cit.>. It was previously experimentally implemented for a d=2 QED code in Ref. <cit.>; here, we implement it for a QEC code utilizing real-time decoding and error correction.

The simpler teleportation circuit can be seen in Fig. <ref> (b). 
The beginning of the circuit is similar to the other experiments, using encoding circuits with verification ancilla implemented in a repeat-until-success protocol to encode |0⟩_L. 
The repeat-until-success circuit is performed up to three times for both logical qubits to achieve high-fidelity input states.
From there, the joint Pauli Z_1Z_2 logical operator is measured, followed by a full QEC gadget measuring both the flagged and conditional unflagged syndrome extraction protocol.
The rest of the circuit, including decoding, correction tracking via Pauli frame, transversal single qubit gates, and destructive measure outs, are performed like all the other experiments. 

We measure this lattice surgery circuit, which we call M_ZZ, to have a process fidelity of 0.887^+7_-7 and when further post-selected as a QED code, 0.992^+1_-1. 
Only 20 qubits were needed in this implementation, 10 for each individual code block.
Further details are given in Fig. <ref> and Appendix <ref>.



§ DISCUSSION




The main results of all the experiments are in Fig. <ref> and Table <ref> (see Appendix <ref> for additional details). The data in Fig. <ref> reflects the asymmetric noise environment of the H-series quantum computers. As Ref. <cit.> notes, the circuit error budget is dominated by two physical layer noise sources - two-qubit gate errors and memory errors. While the gate errors are not completely without structure, we find that a depolarizing error model usually captures their impact on typical circuits. However, memory error is strongly dominated by stochastic and coherent rotations about Z. The CSS structure of the [[7,1,3]] code promotes the physical Z errors to the logical level since the logical Z operator is a product of physical Z operators (Fig. 1 in Ref. <cit.>). The eigenstates of logical X and Y are sensitive to unintended logical Z operations and, therefore, yield lower fidelity. Note that the physical layer fidelities do not show the same asymmetry because gate errors dominate the physical circuits more than the logical circuits.

The process fidelity of the physical teleportation experiment is estimated at 0.9895^+3_-3, setting a high bar for achieving the break-even point with logical circuits. The logical transversal experiment without the QEC gadget on logical qubit one exhibits a process fidelity of 0.989^+2_-2, suggesting a break-even milestone. However, it would be more conclusive if logical fidelity surpassed physical fidelity with reasonable statistical separation. Considering our previous work, which is near break-even with transversal two-qubit gates for the Steane code <cit.>, achieving break-even in this context could be plausible. A more stringent and significant break-even milestone for logical teleportation involves comparing the physical circuits to the corresponding logical experiments with mid-circuit QEC gadgets since they are key to preventing logical errors and fault propagation. Doing so, we find the process fidelity of 0.975^+2_-2 to be slightly lower than the corresponding physical process fidelity of 0.9895^+3_-3. We are optimistic that even without further hardware improvements, this process fidelity can be improved by further optimizations at the logical level, as discussed below.

The experiments 0QEC, 1QEC, and MXXMZZ can be viewed as implementing the Knill-style QEC gadget <cit.>. The 0QEC version closely mirrors Knill's original proposal. For Knill-style QEC, X and Z syndromes are assessed during teleportation by destructively measuring logical qubits one and two. These measurements determine logical outcomes and gather syndromes data, which are subsequently decoded. These corrections generated are then not only used to teleport the state but also to fix accumulated faults.

Knill-style QEC is particularly interesting as it supports a wide class of codes capable of logical teleportation, avoids generating hook error when transversal two-qubit gates are used, reduces non-Pauli noise such as leakage, and offers single-shot decoding. This last feature trades reduced time overheads for the requirement of two logical ancillas.

The promising fidelity of 0.989^+2_-2 for the Knill gadget observed in 0QEC suggests its performance. We can calculate the infidelity (one minus the process fidelity) as 1.1e-2 and roughly compare the error rate of QEC gadget used in 1QEC by subtracting the process fidelities of 0QEC from 1QEC. Doing so, we estimate a logical error rate of 1.4e-2, potentially increased by memory errors induced on the other logical qubits during its operation. This indicates the two gadgets may have similar performance; however, future studies should conduct a detailed component-level analysis to properly compare the performance of the different QEC gadget implementations.

Despite these encouraging preliminary estimates, we believe the current results do not definitively confirm whether we have met or exceeded a break-even point for the QEC gadgets. We suggest two informative break-even milestones for assessing QEC gadgets' effectiveness: 1) ensuring the gadget's error rate is at or below that of the physical gate most limiting the performance of general physical algorithms (typically the two-qubit gate) and 2) comparing the error rate of the physical two-qubit gate to that of the fault-tolerant logical two-qubit gate when QEC gadgets are employed. However, to hit break-even milestones at the algorithmic level, logical gates must achieve error rates and order of magnitude lower or more due to the increased count of logical gates. This stems from the discrete sets of protected gates that QEC codes utilize <cit.>.

One notable contribution of this work is the introduction of lattice surgery techniques in the QCCD architecture. Our initial experiments in lattice surgery showed lower process fidelities than the transversal circuits, but we stress that the lattice surgery circuits likely have room for more optimization. One should not draw strong conclusions about the prospects for lattice surgery versus transversal methods in QCCD devices as the H2 design was not optimized for either method, and less time was spent considering how to optimize the lattice surgery protocols. We hope to continue to improve our experimental implementation of these and other logical procedures.

Optimizing the complex structure of the logical circuits was made easier by programming on the logical level utilizing a domain-specific language known as SLR (see Appendix <ref>). Other straightforward optimizations may include different but logically equivalent QEC protocols, reducing leakage errors <cit.>, Clifford deformation <cit.>, dynamical decoupling, Pauli twirling and other circuit-level techniques to suppress coherent noise <cit.>, larger distance codes <cit.>, and improved decoding. The decoders in this work only consider the syndromes and determine corrections for individual subcircuits, such as the QEC gadget and logical measurements. Further improvements in decoding may be possible by incorporating knowledge of the bias noise present in the system as well as by decoding over the collection of all syndromes measured in the circuit <cit.>.

The results in this work represent the state-of-the-art in experimental QEC; however, more work is needed to demonstrate the error suppression promised by QEC. Fortunately, we believe we are far from any fundamental limitations. The largest noise source in the two-qubit gate is spontaneous emission, which can be reduced using different laser wavelengths and power <cit.>. Memory error, especially any coherent component, is also of special concern to the performance of deep logical programs. We note that our results were generated using the software stack available to any user of Quantinuum’s H-series computers and ran alongside customer jobs. The software stack compiler is optimized for general purposes, not specific error correction circuits. 
Thus, the results in this work represent typical performance currently seen for the H2-1 machine.
Custom compilation techniques could reduce transport times and the associated memory error. Also, QCCD ion-traps using 2D geometries <cit.> could significantly increase the clock speed. 

Fault tolerance and error suppression come with an overhead price, and understanding the amount of tolerance needed, at a cost of circuit depth, width, and time, compared to the gain in error suppression is an important consideration as quantum devices scale up.
To this end, we demonstrate the first logical state teleportation and the first instance of lattice surgery for a QEC code, demonstrating the ability of the QCCD technology to explore different QEC paradigms. In that same spirit, another trapped-ion quantum processor recently demonstrated code-switching <cit.>, which could be an enabling technique for non-Clifford operations and should be suitable for QCCD architectures. 
We expect many more studies in the emerging field of experimental QEC to be done to optimize resource requirements, including resource state generation and use, gate set comparisons, and investigating practical fault-tolerance beyond idealized mathematical definitions. Through investigations like these, quantum hardware and tailored QEC protocols may be co-designed to accelerate the progress toward large-scale quantum computing. 




§ ACKNOWLEDGEMENTS


We acknowledge the large team at Quantinuum for all their contributions and the fabrication facility at Honeywell for producing world-class ion traps. We’d also like to thank Ben
Criger for helpful discussions, Jonhas Colina for helping develop the H2-1 compiler, and the good people at IARPA for inspiring discussions. Lastly, we would like to thank Tony Uttley for his leadership, support, and friendship.






