Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2509.04527

The Structure and Interpretation of Quantum Programs I: Foundations

David Wakeham

Published Sep 3, 2025• 0 citations
arXivHTMLPDF

Abstract

Qubits are a great way to build a quantum computer, but a limited way to program one. We replace the usual "states and gates" formalism with a "props and ops" (propositions and operators) model in which (a) the C*-algebra of observables supplies the syntax; (b) states, viewed as linear functionals, give the semantics; and (c) a novel diagrammatic calculus unifies the two. The first part develops the basic objects of the framework, encoding consistent patterns of operator correlation, recovering Hilbert space via the GNS construction, and re-deriving the Bloch sphere as the set of all consistent correlations of operators in the Pauli algebra. We then turn to intervention, showing how measurement modifies state, proving an operator-algebraic version of the Knill-Laflamme conditions, and expressing stabilizer codes with the same diagrammatic machinery. This provides a concise, representation-agnostic account of quantum error correction. The result is a self-contained foundation in which C*-algebras, and their dual Hilbert spaces, offer a rich and universal substrate for quantum programming; forthcoming papers will build a high-level language and quantum software applications on top of this substrate.

DOI
10.48550/arxiv.2509.04527

Related papers

Algebraic and Mathematical Foundations of Quantum Computation: Hilbert Spaces, Group Structures, and Quantum Algorithms

Bhavesh B. Prajapati

Quantum computation is, at bottom, a branch of applied algebra and functional analysis: the state of a quantum register is a unit vector in a finite-dimensional complex Hilbert space, computation is the action of the unitary group on that space, and the structure of the most important quantum algorithms is dictated by the representation theory of finite and continuous groups. This paper develops the mathematical scaffolding of the field from first principles and uses it to explain why quantum computers can outperform classical ones. We review complex inner-product spaces, self-adjoint and unitary operators, the spectral theorem, and the tensor-product construction that gives rise to entanglement and the exponential dimension of the state space. We then describe the qubit and its geometry, the group-theoretic classification of quantum gates (the special unitary groups, the Pauli and Clifford groups, and their Lie-algebraic generators), and the universality results that justify finite gate sets together with the Solovay–Kitaev theorem. With this apparatus we analyse the quantum Fourier transform, phase estimation, and the hidden subgroup problem, showing how Shor’s factoring algorithm, Grover’s search, and the quantum linear-systems algorithm arise as instances of a small number of algebraic templates. Finally we treat the stabilizer formalism of quantum error correction—where finite abelian groups over GF(2) play the central role—and the variational, near-term (NISQ) algorithms that dominate current practice. Throughout, the emphasis is on the algebraic invariants that make quantum speed-ups possible.

Communications on Applied Nonlinear Analysis•Jan 24, 2025•0 citations

Denotational semantics for stabiliser quantum programs

Robert I. Booth, Cole Comfort

The stabiliser fragment of quantum theory is a foundational building block for quantum error correction and the fault-tolerant compilation of quantum programs. In this article, we develop a sound, universal and complete denotational semantics for stabiliser operations which include measurement, classically-controlled Pauli operators, and affine classical operations, in which quantum error-correcting codes are first-class objects. The operations are interpreted as certain affine relations over finite fields. This offers a conceptually motivated and computationally-tractable alternative to the standard operator-algebraic semantics of quantum programs (whose time complexity grows exponentially as the state space increases in size). We demonstrate the power of the resulting semantics by describing a small, proof-of-concept assembly language for stabiliser programs with fully-abstract denotational semantics.

cs.LOCross-listedarXiv:2511.22734•Dec 1, 2025•2 citations

Introduction to Quantum Computing

Walid E. Gomaa

This presentation provides a comprehensive overview of the foundational principles of quantum computation. It begins by contrasting classical and quantum information, highlighting how quantum bits (qubits) leverage superposition, entanglement, and interference to process information in ways that surpass classical limits. The document explains the four postulates of quantum mechanics: state space (qubits as unit vectors in a Hilbert space), time evolution (via unitary operators), measurement (probabilistic collapse of the state), and composite systems (tensor products of subsystems). Key concepts such as the Bloch sphere representation, quantum gates (e.g., Hadamard, CNOT, Pauli gates), and quantum circuits are discussed, illustrating how quantum operations manipulate qubit states. The presentation also covers quantum evolution, the gate model for computation, and the universality of certain gate sets, emphasizing the potential for quantum parallelism and the transformative impact of quantum computing on fields like cryptography and optimization.

•Nov 11, 2025•0 citations

From Bounded Surjections to Quantum Error-Correcting Codes: An Operator-Algebraic Construction

Sudoma, Oksana

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 .

•Nov 15, 2025•0 citations

Logical Structures Underlying Quantum Computing

Federico Holik, Giuseppe Sergioli, Hector Freytes +1 more

In this work we advance a generalization of quantum computational logics capable of dealing with some important examples of quantum algorithms. We outline an algebraic axiomatization of these structures.

arXiv:1811.06808•Entropy•Jan 16, 2019•9 citations

Programming with Quantum-Controlled Quantum Channels

Kengo Hirata, Takeshi Tsukada

In contrast to a classical bit, which can only take the value $0$ or $1$, its quantum counterpart -- a qubit -- can exist in a superposition of $0$ and $1$. This is a superposition of data values, naturally raising the question of whether one can superpose not only data but also programs. For example, a particular superposition of programs, known as the quantum SWITCH, has attracted much attention, and its implementations and computational advantages have been studied extensively within the physics community. A naive way to control a program by a qubit is by means of a controlled operation. Given an operation $F$, this amounts to considering an operation that behaves as $F$ when the control qubit is $|1\rangle$, and as the identity operation when the control qubit is $|0\rangle$. This idea works well when $F$ is a unitary operation, but it is not well-defined for a general quantum channel. By contrast, the quantum SWITCH is free from the well-definedness issue. This contrast leads to the key insight of this paper: controlled operations and the quantum SWITCH should be regarded as different kinds of quantum control mechanisms. Building on this insight, we develop a novel quantum programming language with quantum control and measurement that can express the quantum SWITCH over quantum channels. Using a semantic analysis based on program transformations, we identify the source of the ill-behavedness of controlled operations as the \emph{correspondence problem}: a lack of coordination between the measurements performed in the then- and else-branches of quantum conditional branching. We address this problem with a linear type system that enforces alignment of the quantum operations used in the two branches, yielding a well-behaved language capable of expressing the quantum SWITCH.

cs.PLCross-listedarXiv:2607.15873•Jul 20, 2026•0 citations
Qubits are a great way to build a quantum computer, but a limited way to program one. We replace the usual "states and gates" formalism with a "props and ops" (propositions and operators) model in which (a) the C*-algebra of observables supplies the syntax; (b) states, viewed as linear functionals, give the semantics; and (c) a novel diagrammatic calculus unifies the two. The first part develops the basic objects of the framework, encoding consistent patterns of operator correlation, recovering Hilbert space via the GNS construction, and re-deriving the Bloch sphere as the set of all consistent correlations of operators in the Pauli algebra. We then turn to intervention, showing how measurement modifies state, proving an operator-algebraic version of the Knill-Laflamme conditions, and expressing stabilizer codes with the same diagrammatic machinery. This provides a concise, representation-agnostic account of quantum error correction. The result is a self-contained foundation in which C*-algebras, and their dual Hilbert spaces, offer a rich and universal substrate for quantum programming; forthcoming papers will build a high-level language and quantum software applications on top of this substrate.
Quantum computation is, at bottom, a branch of applied algebra and functional analysis: the state of a quantum register is a unit vector in a finite-dimensional complex Hilbert space, computation is the action of the unitary group on that space, and the structure of the most important quantum algorithms is dictated by the representation theory of finite and continuous groups. This paper develops the mathematical scaffolding of the field from first principles and uses it to explain why quantum computers can outperform classical ones. We review complex inner-product spaces, self-adjoint and unitary operators, the spectral theorem, and the tensor-product construction that gives rise to entanglement and the exponential dimension of the state space. We then describe the qubit and its geometry, the group-theoretic classification of quantum gates (the special unitary groups, the Pauli and Clifford groups, and their Lie-algebraic generators), and the universality results that justify finite gate sets together with the Solovay–Kitaev theorem. With this apparatus we analyse the quantum Fourier transform, phase estimation, and the hidden subgroup problem, showing how Shor’s factoring algorithm, Grover’s search, and the quantum linear-systems algorithm arise as instances of a small number of algebraic templates. Finally we treat the stabilizer formalism of quantum error correction—where finite abelian groups over GF(2) play the central role—and the variational, near-term (NISQ) algorithms that dominate current practice. Throughout, the emphasis is on the algebraic invariants that make quantum speed-ups possible.
The stabiliser fragment of quantum theory is a foundational building block for quantum error correction and the fault-tolerant compilation of quantum programs. In this article, we develop a sound, universal and complete denotational semantics for stabiliser operations which include measurement, classically-controlled Pauli operators, and affine classical operations, in which quantum error-correcting codes are first-class objects. The operations are interpreted as certain affine relations over finite fields. This offers a conceptually motivated and computationally-tractable alternative to the standard operator-algebraic semantics of quantum programs (whose time complexity grows exponentially as the state space increases in size). We demonstrate the power of the resulting semantics by describing a small, proof-of-concept assembly language for stabiliser programs with fully-abstract denotational semantics.
This presentation provides a comprehensive overview of the foundational principles of quantum computation. It begins by contrasting classical and quantum information, highlighting how quantum bits (qubits) leverage superposition, entanglement, and interference to process information in ways that surpass classical limits. The document explains the four postulates of quantum mechanics: state space (qubits as unit vectors in a Hilbert space), time evolution (via unitary operators), measurement (probabilistic collapse of the state), and composite systems (tensor products of subsystems). Key concepts such as the Bloch sphere representation, quantum gates (e.g., Hadamard, CNOT, Pauli gates), and quantum circuits are discussed, illustrating how quantum operations manipulate qubit states. The presentation also covers quantum evolution, the gate model for computation, and the universality of certain gate sets, emphasizing the potential for quantum parallelism and the transformative impact of quantum computing on fields like cryptography and optimization.
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 .
In contrast to a classical bit, which can only take the value 000 or 111, its quantum counterpart -- a qubit -- can exist in a superposition of 000 and 111. This is a superposition of data values, naturally raising the question of whether one can superpose not only data but also programs. For example, a particular superposition of programs, known as the quantum SWITCH, has attracted much attention, and its implementations and computational advantages have been studied extensively within the physics community. A naive way to control a program by a qubit is by means of a controlled operation. Given an operation FFF, this amounts to considering an operation that behaves as FFF when the control qubit is ∣1⟩|1\rangle∣1⟩, and as the identity operation when the control qubit is ∣0⟩|0\rangle∣0⟩. This idea works well when FFF is a unitary operation, but it is not well-defined for a general quantum channel. By contrast, the quantum SWITCH is free from the well-definedness issue. This contrast leads to the key insight of this paper: controlled operations and the quantum SWITCH should be regarded as different kinds of quantum control mechanisms. Building on this insight, we develop a novel quantum programming language with quantum control and measurement that can express the quantum SWITCH over quantum channels. Using a semantic analysis based on program transformations, we identify the source of the ill-behavedness of controlled operations as the \emph{correspondence problem}: a lack of coordination between the measurements performed in the then- and else-branches of quantum conditional branching. We address this problem with a linear type system that enforces alignment of the quantum operations used in the two branches, yielding a well-behaved language capable of expressing the quantum SWITCH.