Source-linked AI summary
Low overhead quantum computation using lattice surgery
Austin G. Fowler, Craig Gidney
TL;DR
Fault-tolerant surface-code overhead has often been estimated with defects and braiding. This paper develops lattice-surgery constructions for storage, multi-body operations, and distillation, finding substantially lower qubit requirements while retaining comparable runtime for a representative algorithm.
Problem
Previous surface-code overhead calculations used defects and braiding, motivating resource estimates for an alternative lattice-surgery approach.
Method
The paper systematically builds lattice-surgery techniques for arbitrary algorithms, including rotated-qubit storage, compact multi-body measurements, and state-distillation procedures.
Results
3.7×10^5 physical qubits support an algorithm with 10^8 T gates and 100 logical qubits in 5.4 hours, versus 1.8×10^6 qubits in 4.5 hours using defects and braiding.
Takeaways & Limitations
The near factor-of-5 qubit saving with comparable runtime implies that defects and braiding should be deprecated in favor of lattice surgery.
Abstract
from arXiv · showhide
When calculating the overhead of a quantum algorithm made fault-tolerant using the surface code, many previous works have used defects and braids for logical qubit storage and state distillation. In this work, we show that lattice surgery reduces the storage overhead by over a factor of 4, and the distillation overhead by nearly a factor of 5, making it possible to run algorithms with $10^8$ T gates using only $3.7\times 10^5$ physical qubits capable of executing gates with error $p\sim 10^{-3}$. These numbers strongly suggest that defects and braids in the surface code should be deprecated in favor of lattice surgery.
I. INTRODUCTION
The paper develops lattice-surgery techniques for surface-code computation and compares their resource requirements with defect-and-braiding approaches. Rotated logical qubits support lower-overhead storage, operator movement, initialization, and multi-qubit measurements.
- I. INTRODUCTION: Nearly a factor of 5 fewer qubits enables general algorithms with comparable time using lattice surgery rather than defects and braiding.The comparison motivates replacing defect-and-braiding overhead estimates with lattice-surgery estimates.
- II. STORAGE: 3d^2 physical qubits are required per rotated logical qubit, compared with 12.5d^2 for a regularly packed double-defect logical qubit.Rotated logical qubits contain d^2 data qubits and d^2−1 measure qubits and can be arranged for local operations and workspace movement.
- III. LOGICAL INITIALIZATION AND MEASUREMENT: Logical |0L⟩ and |+L⟩ are prepared by initializing all data qubits and measuring every stabilizer d times.The corresponding procedures initialize data qubits to |0⟩ or |+⟩ before repeated stabilizer measurement.
- III. LOGICAL INITIALIZATION AND MEASUREMENT: Logical operators can be moved by multiplying stabilizer measurement results, with the accumulated sign relating the new operator to the old one.Logical X or Z measurements similarly use corrected products of data-qubit measurement outcomes along indicated lines.
- IV. XX AND ZZ LOGICAL MEASUREMENT: Logical XX and ZZ measurements use stabilizer patterns measured d times, then assign the resulting eigenvalue and accumulated sign after splitting.The procedures support equal-size and unequal-size logical qubits.
V. MULTI-BODY OPERATOR MEASUREMENTS
Lattice surgery provides compact procedures for measuring multi-body X and Z operators, extending beyond two-logical-qubit measurements to mixed operators.
- V. MULTI-BODY OPERATOR MEASUREMENTS: Lattice surgery can compactly measure multi-body X and Z operators.The paper gives explicit steps for multi-body X measurements and a procedure for logical XXZ measurements; mixed operators may require logical-qubit rotations.
VI. STATE INJECTION
The paper analyzes 15-to-1 state distillation and state injection for lattice-surgery-based computation. It combines heralded injection, code-distance expansion, and stabilizer-based error detection, while also specifying gate assumptions relevant to the construction.
- VI. STATE INJECTION: State injection can create a distance-7 rotated logical qubit in an arbitrary state with approximately 50% heralded success and accepted error p_i equal to the physical two-qubit gate error rate.The cited simulations used un-rotated square logical qubits, while the paper considers injecting |T⟩.
- VI. STATE INJECTION: Two error-detection rounds perform injection, followed by approximately one further round to determine whether the injection succeeded.The construction uses clusters of 20 injection attempts and expands successful states to distance 15.
- VI. STATE INJECTION: 15 error-detection cycles are assumed sufficient to implement S/S† on a distance-15 surface code with distance no less than 7.This implementation can require extended, irregular, and higher-weight stabilizer measurements.
IX. HALF DISTANCE ROTATION
The section describes in-place half-distance rotation and lattice-surgery preparation, injection, and distillation procedures for reliable |T⟩ states.
- IX. HALF DISTANCE ROTATION: Halving the code distance enables in-place 90° rotation when space is limited.The method is sufficient for the section’s purposes.
- X. DISTILLATION: 50% heralded injection success provides space for 20 attempts during 15 rounds of a distance 15 code.A successful injection is expanded from distance 7 to distance 15 for more reliable storage.
- X. DISTILLATION: 15 qubits uniquely encode binary values from 1 to 15, locating one Z error and detecting arbitrary pairs after preparation.The resulting state can be viewed as logical |0⟩ of a distance 3 code.
- X. DISTILLATION: 3.5 × 10^-8 output error results when the complete T† structure has input Z-error probability p_i = 10^-3.The text says this may suffice for medium-term algorithms, while further suppression may be needed for long-term algorithms.
- X. DISTILLATION: At least 16 first-level |T⟩ states are attempted to reliably obtain 15 inputs, with each packed layer having effective height 6.5d at d = 15.Second-level circuits are fitted together to reduce overall execution height and time.
XI. HADAMARD
The section presents a lattice-surgery Hadamard approach that avoids changing logical-operator definitions while using simple underlying circuits.
- XI. HADAMARD: Lattice-surgery Hadamard operations can require doubling logical-qubit size and additional doubling to measure logical Y operators.The approach also requires physical stabilizer measurements of weight greater than 4 and hardware-suitable structure.
- XI. HADAMARD: The proposed Hadamard method preserves logical-operator definitions and uses simple underlying circuits.The proposal is described in Figs. 21–22.
XII. CNOT
The section describes lattice-surgery CNOT implementations for regular and single-control multiple-target operations, with transversal ancilla initialization and measurement.
- XII. CNOT: 2d is the total time required for regular and single-control multiple-target CNOT implementations.The two CNOT forms can be implemented in similar manners.
- XII. CNOT: Ancilla initialization and measurement can both be performed transversely.
XIII. CZ
The section obtains a CZ gate by modifying the lattice-surgery CNOT procedure.
- XIII. CZ: Changing one measured operator converts the preceding CNOT construction into a CZ gate.The modification is illustrated in Fig. 24.
XIV. SWAP
Logical qubits can be moved around one another through a sequence of single-logical-qubit moves.
- Logical qubits are moved around one another using a series of single logical qubit moves.
XV. ALGORITHM OVERHEAD
The overhead analysis assumes one-at-a-time |T⟩ distillation and algorithms dominated by |T⟩ preparation, then compares lattice surgery with defect braiding. For 10^8 T gates and 100 logical qubits, lattice surgery requires far fewer physical qubits with comparable runtime.
- One |T⟩ state is distilled at a time, using simple surface-code detection-event processing to maintain pace with superconducting hardware.The approximate logical error rate per detection round is pL = 0.1(100p)^((d+1)/2).
- Overhead calculations are tractable when Clifford+T algorithms are dominated by |T⟩ preparation and Clifford gates run in parallel with distillation.
- The analysis includes a spreadsheet detailing and performing the required overhead calculations.
- Nearly a factor of 5 fewer qubits is achieved with lattice surgery while retaining comparable runtime to defect-and-braiding estimates.The broader analysis builds techniques for arbitrary algorithms and reports comparable time with nearly fivefold lower qubit count.
- 3.7×10^5 physical qubits and 5.4 hours are required for an algorithm with 10^8 T gates and 100 logical qubits using lattice surgery.The hardware assumptions are a characteristic gate error rate of 10^-3 and a 1 µs surface-code detection-circuit time.
acZ
The paper illustrates lattice-surgery procedures for moving, expanding, contracting, and interacting logical qubits, including CNOT and CZ operations. These layouts preserve code distance through directed movement and error-detection rounds.
- A logical qubit can be moved downward, expanded, contracted, and returned to its original position through stabilizer-pattern operations.The circuit orientation around corners preserves the full code distance.
- Lattice surgery implements CNOT and extends it to a single-control, multiple-target operation.
- Lattice surgery implements CZ and extends it to a single-control, multiple-target operation.
- A representative movement sequence uses downward and rightward motion, followed by an L-shaped return and 3d total error-detection rounds.
- An algorithm layout separates data logical qubits from communication and interaction ancillas around a single distillation level.