Abstract We establish that every bounded surjection π : B ↠ H between Banach and Hilbertspaces canonically induces a quantum error-correcting code structure. The kernel ker π capturesunobservable degrees of freedom, while the quotient B/ ker π encodes protected logical information.This perspective: (1) unifies subspace, subsystem, and operator-algebraic codes under oneframework; (2) provides functorial code transformations via morphisms of surjections; (3)enables computational exploration through kernel geometry analysis; (4) extends naturally toinfinite dimensions via GNS construction without requiring infinite stabilizer sets. We prove thecorrespondence is functorial with a universal property, demonstrate stability under perturbations,and show the Knill-Laflamme conditions emerge from kernel structure. Examples include theShor code arising from syndrome extraction, holographic codes from bulk-boundary maps, andoperator-algebraic codes from GNS representations. Computational validation (ExperimentsE49, E50) confirms kernel dimension predictions with machine-precision accuracy and revealsrank transition behavior in continuous code families, with dimension derivatives |∆k/∆t| ∼ 102at transition points. While finite-dimensional codes are mathematically equivalent to knownconstructions, our framework provides conceptual unification: (1) kernel geometry explains whydifferent QEC approaches converge on the same codes; (2) continuous code families handle ranktransitions without stabilizer redefinition; (3) infinite dimensions via GNS construction avoidinfinite stabilizer sets; (4) functorial transformations arise naturally from surjection morphisms;(5) the approach aligns with physical intuition—error correction protects exactly the informationthat survives observation. Where Surjections Appear Naturally Quantum error correction typically starts with a codespace—a carefully chosen subspace of a larger Hilbert space [ KL97, NC10 , Got97 ]. But nature oftenpresents us with projection maps first:• Coarse-graining: Mapping microscopic states to macroscopic observables• Symmetry reduction: Projecting onto gauge-invariant subspaces• Partial trace: Observing subsystems of composite quantum states• Boundary limits: In AdS/CFT, mapping bulk fields to boundary observablesEach scenario involves a map from a larger space to a smaller observable space. Informationthat survives this projection is precisely what remains accessible. The question naturally arises:Can these projections automatically induce quantum error-correcting structure? This paper answers affirmatively: every bounded surjection canonically induces quantumerror correction structure. The construction applies broadly—from finite qubit codes to infinite-dimensional operator algebras. Consider the concrete scenario of holographic duality: bulk quantum fields map to boundaryCFT observables. Some bulk configurations are invisible from the boundary—they lie in the kernelof the bulk-to-boundary map. The observable bulk information forms a quotient space. Could thisquotient structure automatically define error correction? Our Contribution We prove that every bounded surjection π : B ↠ H from a Banach space ontoa Hilbert space canonically induces a quantum error-correcting code via the quotient constructionfrom functional analysis [Rud91, Con90]. The construction is:1. Universal: Works for finite and infinite-dimensional systems2. Natural: QEC emerges from observability structure (kernel geometry)3. Functorial: Morphisms between surjections induce code transformations Positioning in the Literature This work occupies a unique position at the intersection of threeapproaches to quantum error correction:• vs. Stabilizer QEC [Got97 ]: We provide a dual perspective where codes emerge fromobservables (what we can measure) rather than symmetries (what commutes). This isconceptually inverse but mathematically equivalent in finite dimensions.• vs. Operator Algebra QEC [ KLP05, Pou05 , KL24]: While OAQEC uses von Neumannalgebras to generalize stabilizers, we use surjections to generalize projections. Our frameworkencompasses OAQEC as the special case where B carries algebra structure (Proposition 4).• vs. Holographic QEC [ ADH15, PYHP15]: Holographic codes implicitly use bulk-to-boundary maps. We make this explicit, showing these maps are surjections whose kernelsencode gauge redundancy. Our Contribution We do not claim new codes but rather a unifying framework that:1. Explains why these approaches converge on the same codes (they all induce surjections)2. Provides computational tools via kernel geometry analysis3. Enables systematic code exploration by designing surjections rather than searching for stabi-lizers4. Naturally extends to infinite dimensions where stabilizers become unwieldyThe key insight: error correction is fundamentally about preserving observable information underlimited measurement resolution—the kernel captures what’s unmeasurable, the quotient preserveswhat survives. Experiments E49: Kernel Geometry Visualization Validates [[4,2,2]] quantum code construction from bounded surjections. Key results: Code distance d=2 verified Kernel orthogonality: 10^-16 (machine precision) Logical operators detected Runtime: < 1 second Documentation: See experiments/E49_kernel_geometry_viz/ABOUT_THIS_EXPERIMENT.md for complete research narrative (hypothesis → results → interpretation) on https://github.com/boonespacedog/surjection-to-qec.git . Quick start: cd experiments/E49_kernel_geometry_viz python3 -m venv venv source venv/bin/activate pip install -r requirements.txt python3 main.py E50: Functorial Code Morphisms Continuous code family evolution with rank transition detection. Key results: Rank transitions detected at t = 2^n - 1 (discrete phase transitions!) Dimension jumps: |Δdim/Δt| = 198 at critical points Topological protection discovered (codes resist smooth deformation) Runtime: ~1.5 seconds Documentation: See experiments/E50_functorial_code_morphisms/ABOUT_THIS_EXPERIMENT.md for complete research narrative and link to topological interpretations on https://github.com/boonespacedog/surjection-to-qec.git .
Abstract We establish that every bounded surjection π : B ↠ H between Banach and Hilbertspaces canonically induces a quantum error-correcting code structure. The kernel ker π capturesunobservable degrees of freedom, while the quotient B/ ker π encodes protected logical information.This perspective: (1) unifies subspace, subsystem, and operator-algebraic codes under oneframework; (2) provides functorial code transformations via morphisms of surjections; (3)enables computational exploration through kernel geometry analysis; (4) extends naturally toinfinite dimensions via GNS construction without requiring infinite stabilizer sets. We prove thecorrespondence is functorial with a universal property, demonstrate stability under perturbations,and show the Knill-Laflamme conditions emerge from kernel structure. Examples include theShor code arising from syndrome extraction, holographic codes from bulk-boundary maps, andoperator-algebraic codes from GNS representations. Computational validation (ExperimentsE49, E50) confirms kernel dimension predictions with machine-precision accuracy and revealsrank transition behavior in continuous code families, with dimension derivatives |∆k/∆t| ∼ 102at transition points. While finite-dimensional codes are mathematically equivalent to knownconstructions, our framework provides conceptual unification: (1) kernel geometry explains whydifferent QEC approaches converge on the same codes; (2) continuous code families handle ranktransitions without stabilizer redefinition; (3) infinite dimensions via GNS construction avoidinfinite stabilizer sets; (4) functorial transformations arise naturally from surjection morphisms;(5) the approach aligns with physical intuition—error correction protects exactly the informationthat survives observation. Where Surjections Appear Naturally Quantum error correction typically starts with a codespace—a carefully chosen subspace of a larger Hilbert space [ KL97, NC10 , Got97 ]. But nature oftenpresents us with projection maps first:• Coarse-graining: Mapping microscopic states to macroscopic observables• Symmetry reduction: Projecting onto gauge-invariant subspaces• Partial trace: Observing subsystems of composite quantum states• Boundary limits: In AdS/CFT, mapping bulk fields to boundary observablesEach scenario involves a map from a larger space to a smaller observable space. Informationthat survives this projection is precisely what remains accessible. The question naturally arises:Can these projections automatically induce quantum error-correcting structure? This paper answers affirmatively: every bounded surjection canonically induces quantumerror correction structure. The construction applies broadly—from finite qubit codes to infinite-dimensional operator algebras. Consider the concrete scenario of holographic duality: bulk quantum fields map to boundaryCFT observables. Some bulk configurations are invisible from the boundary—they lie in the kernelof the bulk-to-boundary map. The observable bulk information forms a quotient space. Could thisquotient structure automatically define error correction? Our Contribution We prove that every bounded surjection π : B ↠ H from a Banach space ontoa Hilbert space canonically induces a quantum error-correcting code via the quotient constructionfrom functional analysis [Rud91, Con90]. The construction is:1. Universal: Works for finite and infinite-dimensional systems2. Natural: QEC emerges from observability structure (kernel geometry)3. Functorial: Morphisms between surjections induce code transformations Positioning in the Literature This work occupies a unique position at the intersection of threeapproaches to quantum error correction:• vs. Stabilizer QEC [Got97 ]: We provide a dual perspective where codes emerge fromobservables (what we can measure) rather than symmetries (what commutes). This isconceptually inverse but mathematically equivalent in finite dimensions.• vs. Operator Algebra QEC [ KLP05, Pou05 , KL24]: While OAQEC uses von Neumannalgebras to generalize stabilizers, we use surjections to generalize projections. Our frameworkencompasses OAQEC as the special case where B carries algebra structure (Proposition 4).• vs. Holographic QEC [ ADH15, PYHP15]: Holographic codes implicitly use bulk-to-boundary maps. We make this explicit, showing these maps are surjections whose kernelsencode gauge redundancy. Our Contribution We do not claim new codes but rather a unifying framework that:1. Explains why these approaches converge on the same codes (they all induce surjections)2. Provides computational tools via kernel geometry analysis3. Enables systematic code exploration by designing surjections rather than searching for stabi-lizers4. Naturally extends to infinite dimensions where stabilizers become unwieldyThe key insight: error correction is fundamentally about preserving observable information underlimited measurement resolution—the kernel captures what’s unmeasurable, the quotient preserveswhat survives. Experiments E49: Kernel Geometry Visualization Validates [[4,2,2]] quantum code construction from bounded surjections. Key results: Code distance d=2 verified Kernel orthogonality: 10^-16 (machine precision) Logical operators detected Runtime: < 1 second Documentation: See experiments/E49_kernel_geometry_viz/ABOUT_THIS_EXPERIMENT.md for complete research narrative (hypothesis → results → interpretation) on https://github.com/boonespacedog/surjection-to-qec.git . Quick start: cd experiments/E49_kernel_geometry_viz python3 -m venv venv source venv/bin/activate pip install -r requirements.txt python3 main.py E50: Functorial Code Morphisms Continuous code family evolution with rank transition detection. Key results: Rank transitions detected at t = 2^n - 1 (discrete phase transitions!) Dimension jumps: |Δdim/Δt| = 198 at critical points Topological protection discovered (codes resist smooth deformation) Runtime: ~1.5 seconds Documentation: See experiments/E50_functorial_code_morphisms/ABOUT_THIS_EXPERIMENT.md for complete research narrative and link to topological interpretations on https://github.com/boonespacedog/surjection-to-qec.git .
We present a new geometric perspective on quantum error correction based on spectral triples in noncommutative geometry. In this approach, quantum error correcting codes are reformulated as low energy spectral projections of Dirac type operators that separate global logical degrees of freedom from local, correctable errors. Locality, code distance, and the Knill Laflamme condition acquire a unified spectral and geometric interpretation in terms of the induced metric and spectrum of the Dirac operator. Within this framework, a wide range of known error correcting codes including classical linear codes, stabilizer codes, GKP type codes, and topological codes are recovered from a single construction. This demonstrates that classical and quantum codes can be organized within a common geometric language. A central advantage of the spectral triple perspective is that the performance of error correction can be directly related to spectral properties. We show that leakage out of the code space is controlled by the spectral gap of the Dirac operator, and that code preserving internal perturbations can systematically increase this gap without altering the encoded logical subspace. This yields a geometric mechanism for enhancing error correction thresholds, which we illustrate explicitly for a stabilizer code. We further interpret Berezin Toeplitz quantization as a mixed spectral code and briefly discuss implications for holographic quantum error correction. Overall, our results suggest that quantum error correction can be viewed as a universal low energy phenomenon governed by spectral geometry.
Quantum information processing promises exponential advantages for certain computational and communication tasks, but practical quantum devices are inherently vulnerable to decoherence and operational imperfections. This thesis develops new algebraic and analytical tools for quantum error correction (QEC) aimed at unifying entanglement-assisted coding theory with operator-algebra frameworks, while also providing mathematically rigorous insights for continuous-variable photonic implementations. First, we introduce the framework of entanglement-assisted operator algebra quantum error correction (EA-OAQEC), extending entanglement-assisted QEC in an operator-algebra context. Built on a stabilizer-based formalism, EA-OAQEC unifies and generalizes subspace, subsystem, and hybrid classical-quantum entanglement-assisted codes. We establish a master error-correction theorem, define a generalized distance notion, and develop constructive techniques including gauge fixing, clean-qubit transformations, and entanglement-assisted gauge-fixing procedures. Second, we study general logical operators: unitaries that preserve a stabilizer codespace beyond the traditional Pauli normalizer. We derive explicit structure theorems for the centralizer and normalizer in the full unitary setting and show how normalizer transformations can be parameterized via classical bit matrix multiply complement (BMMC) permutations. Finally, motivated by photonic quantum computing, we analyze finite-rank compressions of the continuous position and momentum operators relevant to Gottesman-Kitaev-Preskill (GKP) codes. We prove that the spectra of these compressions are governed by the roots of classical Hermite polynomials and connect the compressed operators to physically realizable approximations of displacement operations and finite-energy GKP states.
We develop a holomorphic representation of quantum error correction codes (QECCs) within the Segal--Bargmann space. By encoding qubits into Schwinger boson modes (zaj,zbj) subject to a degree-one homogeneity constraint, we derive closed-form differential operator representations for stabilizers, syndrome extraction, and recovery for fundamental codes (three-, five-, seven-, and nine-qubit codes). Quantum errors are characterized as holomorphic perturbations violating this constraint, while syndrome measurement projects onto eigenspaces of commuting differential operators. Restricting to unit-magnitude variables (∣z∣=1) reveals a toroidal space $\T^{2n}$ where error syndromes manifest as discrete translations in winding number space Z2n, and recovery acts as Hamiltonian flows restoring the winding configuration. In the full Segal--Bargmann space, the code space is a holomorphic submanifold of $\CP^{2^n-1}$, with correctable errors as transverse normal directions. Consequently, the Knill--Laflamme condition becomes a Fubini--Study orthogonality condition between the code submanifold and its error-translated images. Topological protection emerges from the U(1)n fiber bundle structure: global phase noise along fibers is unobservable, while base-space errors require active correction. Finally, we establish a path-integral formulation for semiclassical error correction dynamics and show that geometric entanglement via the Segre embedding naturally quantifies code distance. This framework unifies algebraic, geometric, and topological perspectives on fault-tolerant quantum protocols.
Abstract We first show that a class of operators acting on a given bipartite pure state on ℋ A ⊗ ℋ B can shrink its supports on ℋ A ⊗ ℋ B to only ℋ A or ℋ B while keeping its mappings. Using this result, we show how to systematically construct the decoders of the quantum error-correcting codes against erasure errors. The implications of the results for the operator dictionary in the AdS/CFT correspondence are also discussed. The “sub- algebra code with complementary recovery” introduced in the recent work of Harlow is a quantum error-correcting code that shares many common features with the AdS/CFT correspondence. We consider it under the restriction of the bulk (logical) Hilbert space to a subspace that generally has no tensor factorization into subsystems. In this code, the central operators of the reconstructed algebra on the boundary subregion can emerge as a consequence of the restriction of the bulk Hilbert space. Finally, we show a theorem in this code which implies the validity of not only the entanglement wedge reconstruction but also its converse statement with the central operators.
We introduce an intrinsic formulation of quantum error correction based on representation theory, in which error-protection structure is encoded directly in a unitary group representation, rather than being tied to a particular embedding into a larger Hilbert space. In this framework, error models are classified according to the isotypic decomposition of the conjugation action on the operator algebra.
Our main result, the \emph{Schur bootstrap}, shows that if an intrinsic code satisfies the Knill--Laflamme conditions on a given symmetry sector, then the same error-protection relations hold for every extrinsic realization obtained from a group-equivariant isometric embedding into a larger Hilbert space. Thus a single intrinsic verification certifies the corresponding symmetry-resolved error-correction conditions across an entire family of physical realizations.
We further introduce an intrinsic notion of distance, called depth, defined via adjoint order. For standard multi-qudit systems this coincides with conventional code distance, while for more general representations it refines the usual weight-based notion. We also prove an intrinsic Eastin--Knill theorem: any intrinsic code of depth at least two has a discrete logical symmetry group, with the obstruction to continuous covariant gates arising from the representation-theoretic structure of the adjoint action.
We illustrate the framework with several examples, including a minimal SU(2) construction that unifies permutation-invariant qubit codes and bosonic codes, and higher-dimensional constructions exhibiting transversal Clifford symmetries and realizations beyond qubit systems.
Quantum error correction and symmetry arise in many areas of physics, including many-body systems, metrology in the presence of noise, fault-tolerant computation, and holographic quantum gravity. Here, we study the compatibility of these two important principles. If a logical quantum system is encoded into n physical subsystems, we say that the code is covariant with respect to a symmetry group G if a G transformation on the logical system can be realized by performing transformations on the individual subsystems. For a G-covariant code with G a continuous group, we derive a lower bound on the error-correction infidelity following erasure of a subsystem. This bound approaches zero when the number of subsystems nor the dimension d of each subsystem is large. We exhibit codes achieving approximately the same scaling of infidelity with n or d as the lower bound. Leveraging tools from representation theory, we prove an approximate version of the Eastin-Knill theorem for quantum computation: If a code admits a universal set of transversal gates and corrects erasure with fixed accuracy, then, for each logical qubit, we need a number of physical qubits per subsystem that is inversely proportional to the error parameter. We construct codes covariant with respect to the full logical unitary group, achieving good accuracy for large d (using random codes) or n (using codes based on W states). We systematically construct codes covariant with respect to general groups, obtaining natural generalizations of qubit codes to, for instance, oscillators and rotors. In the context of the AdS/CFT correspondence, our approach provides insight into how time evolution in the bulk corresponds to time evolution on the boundary without violating the Eastin-Knill theorem, and our five-rotor code can be stacked to form a covariant holographic code.