Quantum computing · Experiment

Teleportation of Logical Qubits using Lattice Surgery with Superconducting Circuits

Luca Hofele, Yongxin Song, Áron Márton, Ian Hesner, Ilya Besedin, Jakob Ekert, Jonathan Trebst, François Swiadek, Felix Henrich, Dante Colao Zanúz, Mohsen Bahrami Panah, Lukas Bödeker, Nicholas Gialouris, Chrysander D. Hagen, Marek Pechal, Jean Claude Besse, Markus Müller, Christoph Hellings, Andreas Wallraff

arXiv:2611.23165v1 ↗PDF ↗Submitted 17 November 2026

Question
Lattice surgery performs logical operations between surface-code qubits by merging two code patches, which measures a joint logical Pauli operator, and splitting them again. Earlier demonstrations reported the fidelity of the final state. What happens to the logical information during the protocol, in particular in the rounds right after a merge, when the joint measurement outcome is still exposed to single faults? And can stabilizer rounds that fault tolerance does not need be removed to improve the result?
Result
On a 41-qubit superconducting device, two distance-3 surface-code qubits are merged into a 3×7 patch, which measures \(X_{L1}X_{L2}\), then split, and the source is measured in the \(Z\) basis; with Pauli-frame updates this teleports the state of L1 to L2. Built from separately fault-tolerant modules, the protocol teleports \(Z\) and \(X\) eigenstates with success probabilities 0.57 and 0.65. Tracking the logical observables step by step shows the \(X\) observable falling from 0.72 to 0.23 at the merge, more than errors on the data qubits explain, and recovering to 0.36 after two further rounds of stabilizer measurements. Combining modules and omitting rounds not needed for fault tolerance raises the success probabilities to 0.65 and 0.73.

The paper in detail

A surface-code patch stores one logical qubit in a grid of data qubits whose \(X\)- and \(Z\)-type parities (stabilizers) are measured repeatedly through auxiliary qubits. Lattice surgery couples two patches without moving qubits: measuring new stabilizers across the boundary merges them into one larger patch, and the product of those new stabilizer outcomes equals a joint logical operator such as \(X_{L1}X_{L2}\). Stopping those measurements and reading out the boundary qubits splits the patch again. Teleportation needs exactly this. With L1 in the state to be sent and L2 in \(\ket{0}\), measuring \(X_{L1}X_{L2}\) and then \(Z_{L1}\) leaves L2 in the original state up to Pauli corrections fixed by the two outcomes.

The device has 41 flux-tunable transmons in three rows, alternating data and auxiliary qubits, with individual readout resonators and Purcell filters. Two patches of nine data qubits each sit side by side, and three further data qubits and four auxiliary qubits at the interface are used only for the merge. Benchmarks give single-qubit gate errors of \(1.2\times10^{-3}\), controlled-\(Z\) errors of \(1.6\times10^{-2}\) and readout errors near \(1.3\times10^{-2}\). Memory experiments on each patch, decoded by matching with weights learned from syndrome statistics, give logical error rates per cycle of 6.3% and 8.3% (\(Z\) and \(X\)) for L1 and 4.9% for both bases on L2, the difference attributed to two-level-system defects.

Measuring the relevant logical observable after each step shows how the information moves. The \(Z\) observable, carried first by \(Z_{L1}Z_{L2}\), then by the long \(Z\) of the merged patch, then by \(Z_{L2}\), decays steadily at the rate predicted from the memory experiments. The \(X\) observable behaves differently: after the merge it is \(m_XX_{L2}\), whose sign depends on the four interface stabilizers measured in the first merged round. A single measurement error there flips the inferred parity, and the observable drops to 0.23. Two more rounds give the parity a timelike distance of three, and the observable recovers to 0.36 before ending at 0.31. Errors on stabilizer support thus dominate the \(X\) basis, yet the \(X\)-basis teleportation still ends better than the \(Z\)-basis one, because the \(Z\) observable suffers more data-qubit errors at every step, above all the long \(Z\) of the merged patch at 15.2% per round.

The optimised circuits treat target initialisation, merge and split, and source measurement as one expand-and-shrink module. Inside it, rounds that only re-establish what transversal readout or a known Pauli frame already supplies can be dropped: first the separate initialisation rounds and the source-patch rounds after the split, then all \(Z\)-type stabilizer rounds and part of the \(X\)-type ones. Fewer syndrome-extraction faults outweigh the longer accumulation of \(Z\) errors at this noise level. The next steps named are real-time and modular decoding, larger distances below threshold, \(Y\)-basis measurement for full logical tomography, and the same step-by-step analysis for logical CNOTs and magic-state cultivation.

Transferable methods

  1. Teleportation as a joint parity measurement by lattice surgery

    Standard teleportation uses a Bell pair and a Bell measurement. Both collapse into a single joint parity measurement followed by a single-qubit measurement, which is the operation lattice surgery provides natively. Tracking the observable that carries the logical information through each step, and comparing it with a product of per-step memory error rates, shows where errors enter.

    Editorial derivation: for \(\ket\psi=\alpha\ket0+\beta\ket1\) on L1 and \(\ket0\) on L2, the projector \(\tfrac12(1+m_XX_1X_2)\) gives \[\tfrac12\bigl[\alpha\ket{00}+\beta\ket{10}+m_X(\alpha\ket{11}+\beta\ket{01})\bigr].\] Measuring \(Z_1\) with outcome \(+1\) leaves \(\alpha\ket0+m_X\beta\ket1\) on L2, corrected by \(Z^{(1-m_X)/2}\); outcome \(-1\) leaves \(\beta\ket0+m_X\alpha\ket1\), corrected by \(X\) and then the same \(Z\). The logical outcomes are inferred from physical data: \(m_X=S_{X5}S_{X6}S_{X7}S_{X8}\), the product of the four interface stabilizers in the merged patch, and \(m_Z\) from the transversal readout of L1, with the readout \(m_S\) of an interface data qubit at the split entering the \(Z\) frame.

    Appendix G models errors only on the data-qubit support of the tracked observable: if a logical flip occurs at step \(i\) with probability \(\epsilon_i\), \[\langle O\rangle_i=(1-2\epsilon_i)\langle O\rangle_{i-1}=\prod_{j\le i}(1-2\epsilon_j)\,\langle O\rangle_0,\] with \(\epsilon_j\) taken from the memory experiments: 10.6% per step for \(Z_{L1}Z_{L2}\) (two patches combined), 15.2% for the merged \(Z\), 8.3% and 2.5% for the \(X\) observables before and during the merge, and 4.9% for \(X_{L2}\). Where the measured value falls below this prediction, the extra errors must come from the stabilizers that define the observable's sign.

    Editorial check: starting from the measured 0.77 after the first step, the data-support model predicts a final \(Z\) value of \(0.77\times0.788\times0.696^3\times0.788\approx0.16\), against 0.14 measured. For \(X\) it predicts 0.70 after initialisation (measured 0.72) but 0.56 at the end (measured 0.31). The difference of about 0.25 is the contribution of the interface stabilizers, consistent with the authors' account of the dip after the merge.

    How to reuse it

    Any code-deformation protocol (lattice surgery, patch rotation, magic-state injection and cultivation) can be diagnosed the same way: identify at each step which product of physical operators carries the logical information, measure it, and compare with a product of memory error rates. A shortfall localises errors to the stabilizers that fix the observable's frame.

  2. Fault-tolerant modules and their depletion

    Building a protocol from modules that are each fault-tolerant guarantees fault tolerance of the whole, but repeats work. When modules are combined, information one module would collect may already be supplied by another, through a transversal readout or a known Pauli frame, so some stabilizer rounds can be removed without losing the ability to tolerate any single fault.

    A distance-three module is called fault-tolerant if, with no internal faults, it corrects any single-qubit error on its input and performs the intended logical operation, and if, for an error-free input, any single internal fault leaves the logical operation intact up to a correctable residual error, using only syndrome information from inside the module. For merge and split this needs three rounds of \(X\)-type stabilizers, so that one wrong interface outcome cannot flip the inferred \(X_{L1}X_{L2}\) (timelike distance three), and at least two rounds of \(Z\)-type stabilizers to tell input errors from measurement errors.

    In the expand-and-shrink module the target patch is initialised inside the module and so has no input errors. The source is finally read out transversally in the \(Z\) basis, which yields both the logical outcome and all \(Z\)-type stabilizer values, so single \(Z\)-type input errors on the source can be corrected from that readout. Internal \(Z\) faults can only leave correctable residual errors on the target, because they cannot change the \(X_{L1}X_{L2}\) outcome. All \(Z\)-type rounds can therefore be omitted. The source patch's \(X\) stabilizers have known values from the Pauli frame, so two rounds of them suffice, while the interface and target stabilizers, whose first values are random, still need three.

    The measured trade-off: omitting rounds reduces syndrome-extraction faults but lets \(Z\) errors accumulate for longer. At this device's error rates the first optimisation raises \(|\langle m_Sm_ZZ_{L2}\rangle|\) from 0.14 to 0.23 and leaves the \(X\) basis unchanged (0.30), since the removed modules are sensitive only to \(Z\)-type errors; the second reaches 0.29 and 0.47. Editorial note: in success probability these are 0.57 to 0.65 for \(Z\) and 0.66 to 0.73 for \(X\); the failure probability falls from 0.43 to 0.36 and from 0.34 to 0.27, removing about a fifth of the failures in each basis.

    How to reuse it

    When compiling logical circuits, check fault tolerance of the composite rather than of each gadget: syndrome rounds that duplicate information from adjacent transversal measurements or tracked frames can be removed. The optimal amount of removal depends on the ratio of measurement to idling errors and should be set by device data.

Source: Section III (logical teleportation and Fig. 3), Section IV (time evolution of logical observables), Section V (optimised circuits), Appendix E (modular fault tolerance), Appendix G (data-support error model and Table 1). Based on the linked paper version. Derivations marked as editorial, and suggested uses in other problems, are editorial guidance rather than results of the paper.

Context & limitations

Why it matters. Measuring logical observables at every step turns lattice surgery from a black box into something that can be diagnosed: the data separate errors on the qubits that carry the logical operator from errors on the interface stabilizers that define its sign, and show the temporary loss of fault tolerance after a merge and its restoration by repeated rounds. The optimised circuits show that fault tolerance can be required of a composite operation rather than of every module, and that the stabilizer rounds saved this way improve fidelity in practice.

Limitations. The device operates above the surface-code threshold: two-qubit gate error is \(1.6\times10^{-2}\), weight-four stabilizer error \(7.5\times10^{-2}\), and the logical error per cycle 4.9–8.3% for the separate patches and 15.2% for the \(Z\) observable of the merged patch, so larger distance would not yet help and the success probabilities are far from what computation needs. Only \(Z\) and \(X\) eigenstates were teleported; arbitrary states and \(Y\)-basis measurements are left for later. Runs with detected leakage are discarded (about 95% kept per cycle), decoding is global matching after the fact, and Pauli corrections are applied in post-processing rather than by real-time feed-forward. The simulations use a simplified Pauli noise model without bias, leakage, residual \(ZZ\) coupling or measurement-induced dephasing. The paper contains no statement about AI use.

Description based on the full arXiv HTML of v1, read 2026-11-20: Sections I–VI and Appendices B (operations and schedules), C (leakage rejection, skimmed), E (modular fault tolerance), F and G (data-support error model). Editorial checks: the success probabilities follow from the reported expectation values as \((1+\langle O\rangle)/2\) (0.14→0.57, 0.31→0.655, 0.29→0.645, 0.47→0.735, reported rounded as 0.57, 0.65, 0.65 and 0.73); the combined data-support error \(\epsilon_{Z_{L1}}(1-\epsilon_{Z_{L2}})+\epsilon_{Z_{L2}}(1-\epsilon_{Z_{L1}})=10.6\%\) of Table 1; and the model \(\langle O\rangle_i=\prod_j(1-2\epsilon_j)\langle O\rangle_0\) applied to the reported numbers, which predicts a final \(Z\) value of 0.16 against 0.14 measured, an \(X\) value of 0.70 against 0.72 after initialization, and a final \(X\) value of 0.56 against 0.31 measured; the last gap is the excess the authors attribute to errors on the interface stabilizers.