Title:Homological Closure of the Planar Surface Code: A Fully Rigorous Relative Chain Complex Formulation Description: This paper presents a fully closed and homologically rigorous formulation of the planar open-boundary surface code. Unlike standard expositions that rely on heuristic parity arguments or generator counting, we derive every structural property directly from the relative chain complex C2→∂2C1→∂1C0C_2 \xrightarrow{\partial_2} C_1 \xrightarrow{\partial_1} C_0C2∂2C1∂1C0 over F2\mathbb{F}_2F2. The core results are: Abelian stabilizer structure derived solely from the exactness condition ∂1∘∂2=0\partial_1 \circ \partial_2 = 0∂1∘∂2=0. Logical qubit count identified with the relative homology group H1(Σ,∂rough)H_1(\Sigma,\partial_{\rm rough})H1(Σ,∂rough), computed via the long exact sequence. Anticommuting logical operators guaranteed by Poincaré–Lefschetz duality and nondegenerate pairing. Code distance d=Ld=Ld=L rigorously established using the min-cut/max-flow theorem (Menger’s theorem), eliminating geometric intuition gaps. All arguments are presented in quotient-space form, reducing the surface code to a purely homological stabilization mechanism. Structural Extension In the Appendix, we establish a structural isomorphism between: Homological stabilizer projection in quantum error correction, and Viability-preserving projection in Yang Jihoon Dynamics. Both systems are shown to be quotient constructions under constraint-preserving equivalence relations. This yields a unified structural perspective: Fault-tolerant homological protection≡Viability-preserving dynamical projection Significance This work provides: A mathematically sealed derivation of the planar surface code A homological closure free of informal parity reasoning A structural bridge between quantum error correction and viability dynamics A foundation for interpreting fault tolerance as constrained topological persistence The result is not an analogy, but a quotient-level structural correspondence.
Title:Homological Closure of the Planar Surface Code: A Fully Rigorous Relative Chain Complex Formulation Description: This paper presents a fully closed and homologically rigorous formulation of the planar open-boundary surface code. Unlike standard expositions that rely on heuristic parity arguments or generator counting, we derive every structural property directly from the relative chain complex C2→∂2C1→∂1C0C_2 \xrightarrow{\partial_2} C_1 \xrightarrow{\partial_1} C_0C2∂2C1∂1C0 over F2\mathbb{F}2F2. The core results are: Abelian stabilizer structure derived solely from the exactness condition ∂1∘∂2=0\partial_1 \circ \partial_2 = 0∂1∘∂2=0. Logical qubit count identified with the relative homology group H1(Σ,∂rough)H_1(\Sigma,\partial{\rm rough})H1(Σ,∂rough), computed via the long exact sequence. Anticommuting logical operators guaranteed by Poincaré–Lefschetz duality and nondegenerate pairing. Code distance d=Ld=Ld=L rigorously established using the min-cut/max-flow theorem (Menger’s theorem), eliminating geometric intuition gaps. All arguments are presented in quotient-space form, reducing the surface code to a purely homological stabilization mechanism. Structural Extension In the Appendix, we establish a structural isomorphism between: Homological stabilizer projection in quantum error correction, and Viability-preserving projection in Yang Jihoon Dynamics. Both systems are shown to be quotient constructions under constraint-preserving equivalence relations. This yields a unified structural perspective: Fault-tolerant homological protection≡Viability-preserving dynamical projection Significance This work provides: A mathematically sealed derivation of the planar surface code A homological closure free of informal parity reasoning A structural bridge between quantum error correction and viability dynamics A foundation for interpreting fault tolerance as constrained topological persistence The result is not an analogy, but a quotient-level structural correspondence.
A CSS quantum error-correcting code is, on the nose, a length-three chain complex over F2 : the commutation law HZ H⊤ X = 0 that makes the code valid is exactly the condition ∂ 2 = 0 that makes a chain complex. We take this identification literally and show that the entire working theory of a quantum code is one homological object the same engine computes, at scale, and certifies. The number of logical qubits is the first Betti number, k = dim H1 = n − rank HX − rank HZ = b1 ; the code distance is the systole, the shortest non-contractible cycle. We reproduce the published parameters of state-of-the-art codes exactly—the toric and hypergraph-product families and the IBM bivariate-bicycle codes [[72, 12, 6]], [[144, 12, 12]], [[90, 8, 10]]—cross-validated four independent ways and kernelcertified for the small cases in Cubical Agda, on CPU and GPU. The two scale certificates—the Betti count b1 and the rank-derived logical count k—are themselves kernel-proved to be a single first-homology certificate (a DescentCertificate both readings factor through), closed terminally through a fixed-point engine. We then run the code, not just measure it. (i) The Union-Find decoder is the engine's connected-components reduction, and "a logical error occurred" is the engine's coboundary decision (the residual cycle has nonzero winding); decoding the toric code at growing distance recovers the accuracy threshold near 9.5%, and the optimal (maximum-likelihood) threshold near 11% is the engine's two homology sectors competing as the domain-wall free energy of a random-bond Ising model on the Nishimori line. (ii) A code's distance scaling is its Tanner-graph spectral expansion: the second eigenvalue λ2 versus the Ramanujan bound is a computable certificate (Sipser–Spielman), exact on the topological tier where the spectral gap obeys γ d2 → 4π 2 . (iii) The full chain complex carries metachecks—redundancies among the parity checks—and we compute them: the bivariate-bicycle codes have six, the engines of single-shot error correction; the 4-dimensional toric code's homology (1, 4, 6, 4, 1), with k = b2 = 6, is the tensor of four circle complexes. (iv) The logical error-rate prefactor is the multiplicity of the systole, A = 2L for the toric code, which we compute exactly. (v) Finally the engine measures a topological phase transition: as random noise thickens, torus-wrapping "giant" cycles appear in a sharp homological-percolation transition at pc ≈ 0.5 that sharpens with system size—the same homology machinery now detecting when noise spontaneously writes a logical operator. (vi) The engine runs over any coefficients: qudit (Fp ) codes are chain complexes over Fp , and the integral homology, computed by the Smith normal form, exposes torsion—so a code's logical-qudit count can depend on the qudit dimension, an extra logical appearing exactly when p divides a torsion coefficient (reproducing the known homology of the torus, the Moore spaces, the Klein bottle, and RP2 ). We are careful to fence what is not claimed: minimum distance is NP-hard in general and we compute it only on the systolic tier; the giant-cycle transition is the random-cluster one, distinct from the maximum-likelihood decoding threshold of the random-bond Ising model. The thesis is singular and operational: a quantum code's parameters, its decoder, its quality, its higher-dimensional structure, its performance prefactor, and its phase transition are not six theories but one—homology you can run. Published by The Institute for Applied Ontological Mathematics.
Locality-preserving logical operators in topological codes are naturally fault tolerant, since they preserve the correctability of local errors. Using a correspondence between such operators and gapped domain walls, we describe a procedure for finding all locality-preserving logical operators admitted by a large and important class of topological stabilizer codes. In particular, we focus on those equivalent to a stack of a finite number of surface codes of any spatial dimension, where our procedure fully specifies the group of locality-preserving logical operators. We also present examples of how our procedure applies to codes with different boundary conditions, including color codes and toric codes, as well as more general codes such as Abelian quantum double models and codes with fermionic excitations in more than two dimensions.
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 has shown advantages in several problems over the corresponding classical algorithms. The noisy intermediate-size\n quantum devices with dozens of qubits make it more promising in the\n past decade, as the quantum advantage was demonstrated\n experimentally. Before entering the era of scalable quantum\n computation, one has to resolve the errors in a quantum many-body\n system, which is inevitable due to the environment interaction during\n quantum control processes. The goal of quantum error correction is to\n reduce such errors and increase decoherence time. The most successful candidates of quantum error correction codes are topological codes, especially surface codes, which were discovered by\n Alexei Kitaev. The ordered phase of the 2D\n Ising model on a torus ensures that toric codes are fault-tolerant\n below a critical error probability. Other than the FT threshold,\n the topological codes feature efficient encoding and\n decoding, local measurements, but suffer from asymptotically zero\n code rate. To encode more logical qubits with finite resources, one can loosen the condition on locality and extend to a broader class of quantum\n low-density parity-check (LDPC)codes. There are many known algebraic\n constructions for such codes, but only a precious few of them have\n finite code rates and meet the fault-tolerant condition:\n the stabilizer weight is bounded and the distance scales at least\n logarithmically with the code size. In this thesis, I construct the\n higher-dimensional quantum hypergraph product (HQHP) codes, which\n generalize quantum hypergraph product (QHP) codes and toric codes in\n all dimensions. The HQHP codes projected into a single space gives\n subsystem product codes, which can then be gauge fixed to\n concatenated codes or homological product codes. Those include some\n common CSS codes, like Shor’s codes, Bacon Shor’s codes, and\n subsystem QHP codes. The HQHP codes can be mapped to the tensor\n product of chain complexes, which provides an algebraic framework to\n construct quantum LDPC codes with finite code rates, square root\n distances, FT thresholds and single-shot properties with redundant\n checks. Meanwhile, their rich connection to other codes are very\n instructive and may lead to further optimizations. Regarding the\n remained procedures towards fault-tolerant universal quantum\n computation through quantum LDPC codes, I will discuss the\n fault-tolerant condition for each code, including distance,\n stabilizer weight, decoding, fault-tolerant gates and measurement\n protocols.\n
Homological quantum codes (also called topological codes) are low density parity check error correcting codes that come from surfaces and higher dimension manifolds. Homological codes from surfaces, i.e., surface codes, have also been suggested as a possible way to construct stable quantum memory and fault-tolerant computation. It has been conjectured that all homological codes have a square root bound on there distance and therefore cannot produce good codes. This claim has been disputed in dimension four using the geometric property of systolic freedom. We will show in this paper that the conjecture holds in dimension two due to the negation of systolic freedom, i.e., systolic rigidity.
In fault-tolerant quantum computation, the preparation of logical states is a ubiquitous subroutine, yet significant challenges persist even for the simplest states required. In the present work, we present a unitary, scalable, distance-preserving encoding scheme for preparing Pauli eigenstates in surface codes. Unlike previous unitary approaches whose fault-distance remains constant with increasing code distance, our scheme ensures that the protection offered by the code is preserved during state preparation. Building on strategies discovered by reinforcement learning for the surface-17 code, we generalize the construction to arbitrary code distances and both rotated and unrotated surface codes. The proposed encoding relies only on geometrically local gates, and is therefore fully compatible with planar 2D qubit connectivity, and it achieves circuit depth scaling as O(d), consistent with fundamental entanglement-generation bounds. We design explicit stabilizer-expanding circuits with and without ancilla-mediated connectivity and analyze their error-propagation behavior. Numerical simulations under depolarizing noise show that our unitary encoding without ancillas outperforms standard stabilizer-measurement-based schemes, reducing logical error rates by up to an order of magnitude. These results make the scheme particularly relevant for platforms such as trapped ions and neutral atoms, where measurements are costly relative to gates and idling noise is considerably weaker than gate noise. Our work bridges the gap between measurement-based and unitary encodings of surface-code states and opens new directions for distance-preserving state preparation in fault-tolerant quantum computation.