Transversal Surface-Code Game Powered by Neutral Atoms (2506.18979v1)

Abstract: Neutral atom technologies have opened the door to novel theoretical advances in surface-code protocols for fault-tolerant quantum computation (FTQC), offering a compelling alternative to lattice surgery by leveraging transversal gates. However, a crucial gap remains between the theory of FTQC and its practical realization on neutral atom systems; most critically, a key theoretical requirement -- that syndrome extraction must be performed frequently enough to keep error accumulation below a threshold constant -- is difficult to satisfy in a scalable manner in conventional zoned approach. In this work, we develop a comprehensive theoretical framework that closes such a gap, bridging theoretical advances in surface-code fault-tolerant protocols with capabilities of neutral atoms. Building on the "game of surface code" framework originally developed for superconducting qubits, we introduce an alternative game-based paradigm for transversal-gate FTQC that harnesses the unique strengths of neutral atom arrays. The game rules are designed to enable syndrome extraction at any intermediate step during logical gate implementation, ensuring compatibility with the threshold theorem. We further present an efficient method for designing resource state factories tailored to transversal-gate FTQC. As an application, our framework offers a systematic methodology and high-level abstraction for resource estimation and optimization, demonstrating that space-time performance competitive with a baseline lattice-surgery-based approach on superconducting qubits is possible, even when physical operations on neutral atoms are orders of magnitude slower. These results establish a solid foundation that bridges the theory and experiment of FTQC powered by neutral atoms, charting a well-founded pathway toward scalable, fault-tolerant quantum computers and setting practical directions for technological development.

• The paper introduces a "transversal surface-code game" framework for fault-tolerant quantum computing on neutral atom arrays, optimizing protocols for the hardware.
• The framework enables scalable fault-tolerant quantum computation on neutral atom platforms by resolving the atom shuttling bottleneck.
• The work details pipelined resource state factories and provides quantitative estimates showing competitive performance for large-scale fault-tolerant computation.

Transversal Surface-Code Game Powered by Neutral Atoms: A Formal Overview

This work presents a comprehensive theoretical and architectural framework for fault-tolerant quantum computation (FTQC) using neutral atom arrays, focusing on the efficient implementation of surface-code protocols via transversal gates. The authors address a critical gap between the theoretical requirements of FTQC—particularly the threshold theorem—and the practical constraints of neutral atom hardware, proposing a new abstraction that leverages the unique capabilities of these systems.

Motivation and Context

Neutral atom platforms have demonstrated rapid progress in scalability, gate fidelity, and flexible connectivity. Unlike superconducting qubits, neutral atoms offer reconfigurability and the potential for atom-selective, shuttling-free operations. However, conventional approaches to FTQC, such as lattice surgery, do not fully exploit these features and often incur significant time overhead due to atom shuttling, especially as system size increases. This overhead threatens the ability to perform syndrome extraction frequently enough to maintain error rates below the threshold required for scalable FTQC.

The Transversal Surface-Code Game Framework

The core contribution is the formulation of FTQC as a "transversal surface-code game" on a two-dimensional grid of logical units called cells. Each cell encapsulates a surface-code block and associated syndrome qubits, and can transition between a finite set of operational modes (idle, syndrome extraction, logical gates, measurement, state preparation, etc.). The framework is governed by a rule set that ensures:

• Syndrome extraction can be performed at any intermediate step during logical gate execution, not just at fixed intervals.
• Error accumulation is tracked and bounded: If the accumulated error in a cell approaches a threshold, syndrome extraction is triggered, maintaining compatibility with the threshold theorem.
• Transversal gates and shuttling-free operations are prioritized, exploiting atom-selective gates and measurements to minimize the need for slow, decoherence-prone atom shuttling.

This abstraction generalizes the "game of surface code" approach previously developed for lattice surgery on superconducting qubits, but is tailored to the operational primitives and constraints of neutral atom arrays.

Mode Transition Rules

Cells transition between modes according to a finite rule set, enabling:

• Fault-tolerant logical state preparation (including magic and auxiliary states)
• Logical Clifford and non-Clifford gates via transversal operations and gate teleportation
• Flexible routing and interaction between cells
• Measurement and reset operations
• Resource state distillation via dedicated "factories"

The rules ensure that all operations required for universal quantum computation can be composed from these primitives, with explicit mechanisms for error tracking and correction.

Resource State Factories and Pipelined Distillation

A significant portion of the work is devoted to the design of resource state factories for the efficient, pipelined distillation of magic states ($\ket{T}$), $S$-gate ancillas ($\ket{Y}$), and remote entanglement ($\ket{\Phi}$). The authors generalize CSS code-based distillation protocols to the transversal-gate setting, introducing:

• Pipelined, one-way routing of cells through buffer and measurement regions, minimizing spatial overhead and maximizing throughput.
• Delayed-choice correction in gate teleportation, reducing the need for adaptive routing and enabling parallelization.
• Catalytic and in-place state preparation for $S$ and $T$ gates, compatible with algorithmic fault tolerance and scalable to arbitrarily low logical error rates.

The analysis includes explicit space-time cost models for these factories, showing that with moderate physical qubit counts and realistic operation times, competitive throughput can be achieved even when neutral atom operations are orders of magnitude slower than those in superconducting circuits.

Quantitative Resource Estimation

The framework enables systematic resource estimation for large-scale FTQC. For example, the authors analyze the execution of a 100-qubit, $10^8$ $T$-count Clifford+$T$ circuit with a target logical error rate of $10^{-10}$:

• Physical qubit count: $\sim$76,000 (including data, syndrome, and factory qubits)
• Cycle time: $\sim$610 $\mu$s (dominated by measurement and shuttling)
• Total execution time: $\sim$3.4 hours
• Factory throughput: 25 parallel $\ket{T}$ factories, each producing a distilled magic state every 3 ms

These estimates demonstrate that, despite slower physical operations, the proposed architecture can match or exceed the space-time performance of lattice-surgery-based superconducting qubit systems, provided the unique features of neutral atoms are fully exploited.

Implications and Future Directions

Practical Implications

• Scalability: The framework resolves the scalability bottleneck of shuttling-based syndrome extraction, enabling large-scale FTQC on neutral atom platforms.
• Modularity: The cell-based abstraction supports modular system design, facilitating both hardware development and software compilation.
• Resource Optimization: Systematic resource estimation and bottleneck identification become tractable, guiding experimental priorities (e.g., measurement speed, shuttling optimization, factory design).

Theoretical Implications

• Generalizability: The game-based abstraction can be extended to other codes (e.g., high-rate LDPC codes) and hardware platforms, provided the operational primitives are mapped appropriately.
• Threshold Compatibility: By enforcing syndrome extraction as a first-class operation, the framework ensures that the threshold theorem remains valid even as system size and complexity grow.
• Algorithmic Fault Tolerance: The architecture is compatible with recent advances in correlated decoding and algorithmic fault tolerance, which can further reduce overhead.

Future Developments

• Integration with Photonic Interconnects: The framework naturally extends to multiprocessor architectures, where modules are linked via high-rate photonic interconnects and logical entanglement distillation.
• Incorporation of Advanced Codes: Adapting the rule set and factory design to high-rate or concatenated codes could yield further reductions in space-time overhead.
• Automated Compilation and Scheduling: The abstraction supports the development of automated compilers and schedulers that map high-level quantum circuits to optimal mode-transition sequences on the physical hardware.

Strong Numerical Results and Claims

• Competitive space-time performance: The authors demonstrate that neutral atom systems, when operated under the proposed framework, can achieve execution times and qubit counts on par with or better than superconducting qubit systems, despite slower physical operations.
• Single-round syndrome extraction: By leveraging transversal gates and algorithmic fault tolerance, the framework supports protocols requiring only a single round of syndrome extraction per logical gate, a substantial reduction in overhead compared to conventional approaches.
• Pipelined factory throughput: The pipelined design of resource state factories enables high-throughput magic state distillation with minimal spatial overhead, a key enabler for large-scale quantum algorithms.

Conclusion

This work establishes a rigorous, practically oriented foundation for scalable, fault-tolerant quantum computation on neutral atom platforms. By abstracting the protocol as a transversal surface-code game and aligning the operational primitives with the hardware's unique capabilities, the authors provide both a theoretical bridge and a practical toolkit for the next generation of quantum computers. The framework's modularity, extensibility, and compatibility with advanced error correction and distillation techniques position it as a reference architecture for future developments in neutral atom quantum computing and beyond.