Every overhead discussion in fault-tolerant quantum computing eventually reduces to a census: how many physical qubits stand behind one logical qubit. For the rotated surface code the census is exact arithmetic, 2d squared minus 1, split between d squared data qubits and d squared minus 1 measure qubits. This paper tabulates the census from distance three to forty-one, prices machines of ten, one hundred, one thousand and 6189 logical qubits at representative distances, and adds the multipliers that headline figures omit: routing lanes between patches, spare patches held against fabrication defects, and the measure-qubit share of the control load. The bare census at distance twenty-seven is 1457 physical qubits per logical qubit; a thousand-logical-qubit machine at distance twenty-one already needs 881,000 physical qubits before a single routing lane or factory is counted. Overhead is not a fudge factor applied at the end of a design; it is the design, and it is quadratic in the one parameter, distance, that error rates dictate.
Every overhead discussion in fault-tolerant quantum computing eventually reduces to a census: how many physical qubits stand behind one logical qubit. For the rotated surface code the census is exact arithmetic, 2d squared minus 1, split between d squared data qubits and d squared minus 1 measure qubits. This paper tabulates the census from distance three to forty-one, prices machines of ten, one hundred, one thousand and 6189 logical qubits at representative distances, and adds the multipliers that headline figures omit: routing lanes between patches, spare patches held against fabrication defects, and the measure-qubit share of the control load. The bare census at distance twenty-seven is 1457 physical qubits per logical qubit; a thousand-logical-qubit machine at distance twenty-one already needs 881,000 physical qubits before a single routing lane or factory is counted. Overhead is not a fudge factor applied at the end of a design; it is the design, and it is quadratic in the one parameter, distance, that error rates dictate.
The planar surface code protects quantum information robustly but pays for its two-dimensional layout with an encoding rate that vanishes as the distance grows, so fault-tolerant memories require hundreds to thousands of physical qubits per logical qubit. A recent proposal constructs modular hyperbolic surface and color codes by partitioning a quantum processor into flat Euclidean modules and wiring sparse, static boundary connections between them, yielding semi-hyperbolic codes with constant encoding rate [1,4]. In this paper we provide an independent, fully explicit quantitative analysis of that proposal. Taking the reported parameters — encoding rate k/n=1/16 and distance d≥22 — as inputs, we compute that a twelve-logical-qubit modular memory requires nmod=192 physical qubits, versus 11100 data qubits for twelve distance-22 rotated surface-code patches, a raw overhead reduction of 57.8×; the reduction remains ≥30× even if the true modular implementation uses up to 370 physical qubits. We further develop a seam-noise mixture model and compute the seam-error budget under which the modular advantage survives: with a seam fraction f=0.1443, seam links may carry up to γ≈2.5× the intra-module error rate before a tenfold advantage at matched distance is exhausted. We compare against the [[288,12,18]] bivariate bicycle code (1.5× fewer qubits for the modular code, at strictly larger distance) and situate the proposal within the low-overhead QEC landscape. All arithmetic is shown step by step; all projections are labeled with stated assumptions. ## 1. Introduction Quantum error correction (QEC) is the accepted route to fault-tolerant quantum computation, but the leading practical scheme — the planar surface code — has an encoding rate k/n that tends to zero as the code distance d grows. For a target logical error rate, the required physical-to-logical qubit ratio grows roughly quadra Full text and updates: papers.qnfo.org/papers/low-overhead-quantum-error-correction-with-boundary-connected-planar-modules-a-r/
Quantum computation holds the promise of solving certain complex problems exponentially faster than classical computers. However, the high prevalent noise in current quantum devices impedes the accurate execution of even basic algorithms. This can be remedied by protecting quantum information with a quantum error-correcting code, where the logical information of an algorithmic qubit is spread across multiple physical qubits. Individual quantum errors are then located and corrected by the fault-tolerant measurement of multi-qubit stabilizer operators (parity checks). Unfortunately, error correction and fault tolerance both impose large demands on the qubit overhead: hundreds to thousands of physical qubits per logical qubit.
We reduce the spacetime cost of fault tolerance by redesigning key building blocks of an error-corrected quantum computer. First, we develop a combinatorial proof with flag fault tolerance that exponentially reduces the extra qubits needed to measure a stabilizer of any size, while tolerating one fault. We leverage these proofs to then design state preparation circuits for the Steane and Golay codes with 100% yield. Next, we improve error correction on a planar layout by showing that a distance-four code encoding six logical qubits protects information as well as the distance-five surface code, using one-tenth as many physical qubits. Finally, we optimize the time overhead of logical gates in surface code quantum computers by protecting measurement results with a classical code, cutting computation time by a factor of two to six. Our hardware-agnostic optimizations of fault tolerance overheads thus suggest new routes to advance the timeline of error-free quantum computing.
A logical processor built from neutral atoms, reported in December 2023, operated 48 logical qubits encoded in 280 physical atoms, an encoding census of 5.8 atoms per logical qubit. That census is startlingly lean next to surface-code accounting, where a single logical qubit of useful distance consumes hundreds to over a thousand physical qubits, and the leanness is the point of this paper's audit. The neutral-atom result spends its atoms differently: transversal gates between entire encoded blocks, reconfigurable atom movement in place of fixed coupling graphs, and zoned layouts that separate storage, interaction and readout. The paper prices what the lean census buys and what it does not: the logical qubits are shallow-distance encodings whose error suppression is modest, the architecture's overhead reappears in atom reservoirs, reloading and cycle time rather than in the encoding ratio, and a like-for-like comparison at algorithmic distances restores much of the familiar overhead while preserving genuine structural advantages that this budget itemises.
Fault-tolerant quantum computation requires logical operations that manipulate encoded information while preserving quantum error-correction protection. In planar surface-code architectures, code deformation and lattice surgery provide a local, measurement-based route to such operations. Here we experimentally realize key elements of patch-based surface-code logical processing on a 107-qubit superconducting quantum processor. We first implement a reusable primitive layer comprising merge and split, patch expansion and shrinkage, and deformations mediated by domain walls and twist defects. We then compose these primitives to realize logical state routing, the logical controlled-NOT gate, and the single-qubit Hadamard and phase gates, which together form a Clifford-generating set. All operations are implemented on distance-three rotated surface-code patches with multi-round syndrome extraction and neural-network decoding, without post-selection. Our results advance superconducting surface-code experiments from protected logical memory to active, patch-based fault-tolerant logical operations.
Surface-code quantum error correction (QEC) is pivotal for fault-tolerant quantum computing, but its energy efficiency remains underexplored. This work derives a practical lower bound on the energy cost per logical-qubit operation, accounting for gate-fidelity decay's impact on code distance and physical-qubit overhead. By modeling the energy consumption of gate operations and error correction, we express the total cost as $ E = (E_g N_g + E_c N_c)/N_l $, where $ E_g $, $ E_c $, $ N_g $, $ N_c $, and $ N_l $ represent gate and physical-qubit energy costs, gate counts, physical-qubit counts, and logical qubit counts, respectively. Gate-fidelity decay increases the required code distance $ d $, scaling $ N_c $ and thus $ E $. We propose normalizing computational cost in joules per logical-qubit operation (JPCUB), isolating logical work from error-correction overhead. Quantitative predictions for $ E_g $, $ E_c $, and $ N_c $ remain [to verify], but the functional dependence on $ d $ and gate fidelities is established. This framework informs energy-efficient QEC design and benchmarks. ## 1. Introduction Surface codes enable fault-tolerant quantum computation by encoding logical qubits in a 2D lattice of physical qubits, correcting errors through syndrome measurements. However, the energy cost per logical operation—critical for scalability—remains poorly quantified. While theoretical foundations exist (Raussendorf & Terhal, 2006; Kitaev, 2003), prior work focuses on error-correction thresholds rather than energy efficiency. Here, we address this gap by deriving a lower bound on energy cost, considering how gate-fidelity decay necessitates larger code distances $ d $, increasing physical-qubit overhead $ N_c $. This analysis connects to the joules-per-compute (JPCUB) benchmark, advocating for energy normalization per logical qubit to disentangle computational work from error-correction costs. ## 2. Background Surface codes encode logical qubits using a 2D grid of
FINDING: Surface code logical error rate scales as pL∝(p/pth)⌊(d+1)/2⌋ for distance-d codes, with threshold pth≈0.01 (circuit-level) and rotated code halving qubit overhead at equal distance. | MATH: Logical error rate pL=A(p/pth)⌊(d+1)/2⌋; for odd d, exponent =(d+1)/2; for even d, exponent =d/2. Distance d = minimum weight of logical operator (e.g., d=5 for 49-qubit rotated code). Qubit count: rotated =d2, unrotated =2d2−2d+1. Threshold pth≈0.01 (circuit-level noise), ≈0.11 (code capacity). | CONNECTION: The exponent ⌊(d+1)/2⌋ is the **minimum weight of a logical Z or X operator** — this is the **Manhattan distance** on the square lattice. The rotated surface code is a **d×d square patch** of the square lattice — a **D4 root system** projection (checkerboard lattice). The ratio of qubit counts (rot Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com