@claudetools/tools 0.8.10 → 0.9.0

package/docs/research/2026-01-02-quantum-computation.md

@@ -0,0 +1,635 @@
+# Quantum Computation Models and Type Systems
+
+**Research Date:** 2 January 2026
+**Task:** Understanding quantum computation models and their relationship to classical type systems
+**Key Question:** Can quantum and classical computation be unified in one type system?
+
+---
+
+## Executive Summary
+
+Quantum computation cannot be trivially unified with classical computation in a single type system due to fundamental physical constraints (no-cloning theorem) and mathematical structure differences (linear vs. Cartesian). However, significant theoretical progress has been made through:
+
+1. **Linear Type Theory** - Enforces no-cloning at the type level
+2. **Categorical Quantum Mechanics** - Dagger compact closed categories provide mathematical foundation
+3. **Hybrid Classical-Quantum Languages** - Proto-Quipper, Q#, Qiskit manage the boundary explicitly
+4. **Graphical Calculi** - ZX-calculus enables equational reasoning about quantum processes
+
+The quantum-classical boundary is managed through careful type system design, not eliminated entirely.
+
+---
+
+## 1. Quantum Lambda Calculus
+
+### Overview
+
+Quantum lambda calculus extends classical lambda calculus to model quantum computation by integrating linear types, quantum operations, and classical control. Multiple variants exist, each addressing different aspects of quantum programming.
+
+### Historical Development
+
+**Foundational Work (2003-2006):**
+- [Van Tonder (2003)](https://arxiv.org/abs/quant-ph/0307150) introduced the first quantum lambda calculus
+- [Selinger & Valiron (2004-2006)](https://arxiv.org/abs/cs/0404056) developed a lambda calculus for quantum computation with classical control
+- Both use affine intuitionistic linear logic for type systems
+
+**Recent Advances (2024-2025):**
+
+1. **Lambda-SX (2025)** - [Presented at APLAS 2025](https://link.springer.com/chapter/10.1007/978-981-95-3585-9_8), supports multiple measurement bases in a typed quantum lambda-calculus (LNCS vol 16201)
+
+2. **Qurts (2025)** - "Qurts: Automatic Quantum Uncomputation by Affine Types with Lifetime" published in [POPL 2025](https://dl.acm.org/doi/10.1145/3373718.3394765), introduces automatic resource management
+
+3. **IMALL with Mixed-State Modality (2025)** - "IMALL with a Mixed-State Modality: A Logical Approach to Quantum Computation" (June 2025) provides logical foundations
+
+4. **Review Paper (2024-2025)** - [Comprehensive survey](https://publications.eai.eu/index.php/casa/article/view/9668) of quantum lambda calculi covering QΛ, QLC, Proto-Quipper, and QML
+
+### Key Design Principles
+
+**Call-by-Value Semantics:**
+- Quantum operations must be evaluated eagerly (no lazy evaluation of quantum states)
+- Prevents unintended superposition of classical control flow
+
+**Linear Type Systems:**
+- Enforce "use exactly once" for quantum data
+- Prevents duplication (no-cloning) and deletion (no-deleting) at compile time
+- Based on affine/linear intuitionistic logic
+
+**Classical Control Flow:**
+- Classical data can be duplicated and deleted freely
+- Measurement converts quantum → classical (irreversible)
+- Enables hybrid quantum-classical algorithms
+
+---
+
+## 2. ZX-Calculus: Graphical Quantum Reasoning
+
+### Mathematical Foundation
+
+The [ZX-calculus](https://en.wikipedia.org/wiki/ZX-calculus) is a rigorous graphical language for reasoning about linear maps between qubits, represented as string diagrams called ZX-diagrams.
+
+**Categorical Structure:**
+- ZX-diagrams form a **dagger compact category**
+- Built freely from generators via composition and monoidal product
+- Spiders represent specific tensors connected to form tensor networks
+
+**Generators:**
+- **Green spiders** and **red spiders** arise from complementary observables
+- Each corresponds to a commutative Frobenius algebra in a dagger symmetric monoidal category
+- Their interaction follows Hopf-like laws
+
+### Completeness and Soundness
+
+[Proven complete](https://link.aps.org/doi/10.1103/PhysRevResearch.7.033141): Two ZX-diagrams represent the same linear map if and only if they can be transformed into each other using ZX-calculus rewrite rules.
+
+**Historical Milestone:**
+- Introduced by Bob Coecke and Ross Duncan (2009)
+- Miriam Backens proved completeness for Clifford fragment (2013) - stabiliser quantum mechanics
+- Enables full graphical reasoning for stabiliser circuits without matrices
+
+### Applications
+
+1. **Measurement-Based Quantum Computing** - Describes graph states and MBQC protocols
+2. **Quantum Error Correction** - [Finding and verifying](https://ar5iv.labs.arxiv.org/html/0906.4725) error correcting codes
+3. **Circuit Optimisation** - Automated quantum circuit simplification
+4. **Lattice Surgery** - Language for surface code operations
+
+### Recent Developments (2024-2025)
+
+- [ZX graphical calculus for continuous-variable quantum processes](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.7.033141) (Physical Review Research, 2025)
+- Extension to infinite-dimensional systems
+- Integration with categorical quantum mechanics
+
+---
+
+## 3. Linear Types and the No-Cloning Theorem
+
+### The Physical Constraint
+
+The [no-cloning theorem](https://en.wikipedia.org/wiki/No-cloning_theorem) states that it is impossible to create an independent and identical copy of an arbitrary unknown quantum state.
+
+**Mathematical Basis:**
+- Quantum operations are unitary linear transformations
+- Cloning would require a non-linear operation
+- Fundamental to quantum physics, not a technical limitation
+
+### Type-Theoretic Enforcement
+
+**Key Insight:** [From nLab](https://ncatlab.org/nlab/show/no-cloning+theorem)
+> "When quantum physics is axiomatised by quantum logic in the guise of linear logic/linear type theory, the content of 'no-cloning' and 'no-deleting' is the very 'linearity' of this logic, the absence of a diagonal map and of a projection map for the non-cartesian tensor product."
+
+**Implementation Approaches:**
+
+1. **Linear Types (QML, Qimaera, QWIRE):**
+   - Every function must use each parameter **exactly once**
+   - Prevents state copying at compile time
+   - Inspired by Linear Lambda Calculus
+
+2. **Affine Types (Proto-Quipper):**
+   - Use each parameter **at most once**
+   - Allows deliberate discarding (with caution)
+   - More flexible than pure linear types
+
+3. **Type-Level Programming ([Haskell model](https://sol.sbc.org.br/index.php/sblp/article/view/36952)):**
+   - Enforces no-cloning via memory access patterns
+   - Compile-time prevention of invalid operations
+   - Uses monadic composition for expressiveness
+
+### Linear Dependent Type Theory
+
+**Problem:** High-level quantum languages need:
+- Linear types (no-cloning)
+- Dependent types (circuit families indexed by classical parameters)
+- First-class quantum circuits
+
+**Solution:** [Proto-Quipper-D](https://arxiv.org/abs/2004.13472) (Linear Dependent Type Theory)
+- Combines linear types with dependent types
+- Semantic structure via fibrations of monoidal categories
+- Enables type-safe uncomputation of garbage qubits
+- Supports families like `Vec Qubit n` where `n : Nat`
+
+---
+
+## 4. Practical Quantum Programming Languages
+
+### Quipper: Functional Quantum Programming
+
+[Quipper](https://arxiv.org/abs/1304.3390) is a scalable, expressive, functional, higher-order quantum programming language embedded in Haskell.
+
+**Key Features:**
+- **Embedded DSL** - Implemented as Haskell library, uses Haskell compiler
+- **Scalability** - Has generated circuits with trillions of gates
+- **Automatic Reversibility** - `build_circuit` keyword converts classical functions to reversible circuits
+- **Monadic Semantics** - `Circ` monad for quantum circuits with formal foundations
+- **Well-Founded** - Based on Quantum Lambda Calculus
+
+**Design Philosophy:**
+- High-level, concise representation of quantum algorithms
+- Classical computer controls quantum device
+- Hardware-agnostic (not tied to specific quantum hardware model)
+
+**Proto-Quipper Family:**
+- Proto-Quipper-S (simple)
+- Proto-Quipper-M (monadic)
+- [Proto-Quipper-D](https://dl.acm.org/doi/10.1145/3373718.3394765) (dependent types) - LICS 2020
+- Proto-Quipper with Reversing and Control (EPTCS 2025)
+
+**Current Status:**
+- Release 0.9.0.0 (Dec 2019) - installable via Cabal
+- Active research on formal foundations
+
+### Q#, Qiskit, and Cirq: Industry Frameworks
+
+#### [Q# (Microsoft)](https://www.bluequbit.io/quantum-programming-languages)
+- **High-level domain-specific language** for quantum computing
+- **Hybrid workflows** - Integrates quantum algorithms into classical workflows
+- **Quantum Development Kit (QDK)** - Test on classical and quantum hardware
+- **Type system** - Aims for user-friendliness, manages entanglement and types
+- **Integration** - Works with C#, F#, Python for host programs
+
+#### [Qiskit (IBM)](https://blog.mlq.ai/quantum-programming-with-qiskit/)
+- **Open-source framework** - Python-based, easy-to-use interface
+- **Architecture** - Divided into Terra, Aer, Ignis, and Aqua elements
+- **Focus** - Pulses, circuits, and algorithms for IBM quantum hardware
+- **Abstraction level** - Low-level operations, granular control
+
+#### [Cirq (Google)](https://quantumai.google/cirq)
+- **NISQ-focused** - Designed for Noisy Intermediate-Scale Quantum computers
+- **Noise modeling** - Accurately models quantum noise (crucial for real hardware)
+- **Python library** - Writing, manipulating, optimising quantum circuits
+- **Control** - Hardware details matter for state-of-the-art results
+
+### The Classical-Quantum Boundary
+
+**Hybrid Quantum-Classical Workflows:**
+- [NISQ algorithms](https://quantumzeitgeist.com/cirq-vs-qiskit-vs-q-3-quantum-programming-languages-which-should-you-choose/) iterate between quantum and classical processors
+- Variational algorithms: quantum circuit → measurement → classical optimiser → repeat
+- Quantum device as subroutine called by classical code
+
+**Type Promotion and Conversion ([Qutes](https://arxiv.org/html/2503.13084v1)):**
+- Type promotion between classical and quantum types
+- Quantum → classical via measurement (irreversible)
+- Classical → quantum via state preparation
+
+**Noise and Decoherence:**
+- NISQ devices encounter errors from noise, decoherence, complexity
+- Short circuit depths required
+- Hybrid workflows combine quantum runs with classical postprocessing
+
+---
+
+## 5. Categorical Quantum Mechanics
+
+### Dagger Compact Closed Categories
+
+[Categorical quantum mechanics](https://en.wikipedia.org/wiki/Categorical_quantum_mechanics) takes dagger compact categories as background structure for defining quantum observables and complementarity.
+
+**Definition:**
+- First appeared in Doplicher & Roberts (1989) - reconstruction of compact topological groups
+- Introduced for quantum mechanics by Abramsky & Coecke (2004) as "strongly compact closed categories"
+- Axiomatises quantum mechanics categorically
+
+**Key Properties:**
+
+1. **Compact Closed:**
+   - Related to Choi-Jamiołkowski isomorphism (process-state duality)
+   - Allows wires to be bent in diagrams
+   - Enables entangled states and measurements
+   - Distinguishes "input" vs "output" of processes
+
+2. **Dagger Structure:**
+   - Captures ability to take adjoints of linear maps
+   - Models quantum conjugation
+   - `f†` reverses direction and conjugates
+
+**Graphical Calculus:**
+- [Complete for equational reasoning](https://www.mscs.dal.ca/~selinger/papers/dagger.pdf) (Selinger 2006)
+- Equality of morphisms provable in finite-dimensional Hilbert spaces ⟺ provable in graphical language
+- String diagrams represent morphisms visually
+
+### Expressiveness
+
+**Can Express:**
+- Unitarity
+- Inner products
+- Trace
+- Choi-Jamiolkowsky duality
+- Complete positivity
+- Bell states
+- Teleportation protocol
+- Logic gate teleportation
+- Entanglement swapping
+
+**CPM Construction:**
+- Associates to each dagger compact closed category its "category of completely positive maps"
+- Resulting category is again dagger compact closed
+- Models open quantum systems
+
+### Limitations and Extensions
+
+**Finite vs Infinite Dimensions:**
+- Dagger compact closed structure works for **finite-dimensional** Hilbert spaces
+- Infinite-dimensional spaces require **dagger symmetric monoidal categories** (not compact)
+- Significant portion of quantum physics involves infinite dimensions
+
+**Connection to Linear Logic:**
+- †-compact categories have as internal logic a **fragment of linear logic**
+- Type theory flavour is **linear type theory**
+- Everything about quantum mechanics in †-compact categories has equivalent expression in formal logic/type theory
+
+---
+
+## 6. Can Quantum and Classical Be Unified?
+
+### The Fundamental Differences
+
+#### 1. **Structural Differences**
+
+**Classical Computing:**
+- Cartesian monoidal categories
+- Diagonal map exists: `Δ : A → A ⊗ A` (duplication)
+- Projection map exists: `! : A → 1` (deletion)
+- Classical data can be freely copied and discarded
+
+**Quantum Computing:**
+- Non-Cartesian monoidal categories (linear)
+- No diagonal map (no-cloning theorem)
+- No projection map (no-deleting theorem)
+- Quantum data must be used exactly once
+
+#### 2. **The Measurement Problem**
+
+The [measurement problem](https://en.wikipedia.org/wiki/Measurement_problem) represents a fundamental discontinuity:
+
+**Before Measurement (Quantum):**
+- System in superposition: `|ψ⟩ = α|0⟩ + β|1⟩`
+- Evolution via Schrödinger equation (linear, deterministic)
+- Pure state, quantum information
+
+**After Measurement (Classical):**
+- [Wave function collapse](https://en.wikipedia.org/wiki/Wave_function_collapse) to single eigenstate
+- Nonlinear, stochastic process
+- Mixed state, classical information
+- Irreversible
+
+**The Boundary Question:**
+> "How can one establish a correspondence between quantum reality and classical reality?" - Measurement Problem Wikipedia
+
+No consensus exists on where the quantum-classical divide precisely lies. This is not a technical detail but a foundational issue in quantum mechanics interpretation.
+
+#### 3. **Decoherence vs Collapse**
+
+[Quantum decoherence](https://en.wikipedia.org/wiki/Quantum_decoherence):
+- Explains transition from pure state (superpositions) to mixed state (classical alternatives)
+- System + environment interaction
+- Major challenge for quantum computing
+- **But does not explain wave function collapse** - all alternatives still present
+
+### Approaches to Unification
+
+#### 1. **Type System Stratification**
+
+**Modern Approach:** Don't unify - manage the boundary explicitly
+
+**Example: [Typing Quantum Superpositions](https://link.springer.com/chapter/10.1007/978-3-319-71069-3_22)**
+- Quantum extension of first-order simply-typed lambda calculus
+- Type is **linear on superposition**
+- Allows **cloning of base vectors** (classical data)
+- Interpretation: superposed types = vector spaces, non-superposed = basis
+
+**Example: [qACP Process Algebra](https://ar5iv.labs.arxiv.org/html/1311.2960)**
+- Axiomatisation unifying quantum and classical processes
+- Quantum and classical information can be mixed
+- Unified under quantum process configuration framework
+
+#### 2. **Categorical Approach**
+
+**Special Commutative Dagger Frobenius Algebras:**
+- Model processes yielding **classical information**
+- Classical data can be cloned or deleted
+- Captures classical communication within quantum framework
+
+**Dagger Biproducts:**
+- Used to study classical communication
+- Capture superposition principle
+- Provide categorical semantics for hybrid systems
+
+#### 3. **Linear Homotopy Type Theory**
+
+[HoTT and Computing Conference 2024](https://nyuad.nyu.edu/en/events/2024/april/homotopy-type-theory-and-computing.html):
+- **Linear HoTT** can specify linear quantum circuits parameterised by non-linear classical data
+- Similar to Proto-Quipper family
+- Brings theoretical progress into contact with practical quantum computing
+
+### The Answer: Partial Unification
+
+**What Can Be Unified:**
+1. **Categorical framework** - Monoidal categories encompass both
+2. **Type discipline** - Linear + non-linear types coexist
+3. **Graphical calculi** - String diagrams for both quantum and classical processes
+4. **Dependent types** - Classical parameters index quantum circuit families
+
+**What Cannot Be Unified:**
+1. **Copying semantics** - Classical allows duplication, quantum forbids it
+2. **Measurement** - Irreversible quantum → classical transition
+3. **Superposition** - Quantum states exist in superposition, classical states don't
+4. **Information theory** - Quantum information fundamentally different from classical
+
+**Best Practice:**
+- Use **stratified type systems** (e.g., Proto-Quipper-D)
+- Classical types: Cartesian (can duplicate/delete)
+- Quantum types: Linear (must use exactly once)
+- Explicit conversion via measurement
+- Manage the boundary, don't erase it
+
+---
+
+## 7. What Makes Quantum Fundamentally Different?
+
+### Physical Constraints
+
+1. **No-Cloning Theorem**
+   - Cannot copy arbitrary unknown quantum state
+   - Consequence of linearity of quantum mechanics
+   - [Not a technical limitation](https://www.quantiki.org/wiki/no-cloning-theorem), but physical law
+
+2. **No-Deleting Theorem**
+   - Cannot delete quantum information
+   - Dual to no-cloning
+   - Required by unitarity
+
+3. **Superposition**
+   - [Quantum system exists in multiple states simultaneously](https://postquantum.com/quantum-computing/quantum-superposition/)
+   - Not "unknown classical state" but genuinely both states
+   - `|ψ⟩ = α|0⟩ + β|1⟩` where `|α|² + |β|² = 1`
+
+4. **Entanglement**
+   - Correlations stronger than classical physics allows
+   - Cannot be created classically
+   - Resource for quantum computation
+
+### Type-Theoretic Consequences
+
+1. **Linearity Required**
+   - Type system must prevent duplication
+   - Affine or linear types enforce this
+   - Classical type systems inadequate
+
+2. **Measurement as Type Conversion**
+   - `Quantum a → Classical a` (via measurement)
+   - Irreversible operation
+   - Information loss (`|α|²`, `|β|²` probabilities, not `α`, `β` amplitudes)
+
+3. **Circuit Families Need Dependent Types**
+   - `Vec Qubit n` where `n : Nat`
+   - Classical parameter indexes quantum data structure
+   - Proto-Quipper-D solution: linear dependent types
+
+---
+
+## 8. Existing Quantum Languages: Handling the Boundary
+
+### Summary Table
+
+| Language | Classical-Quantum Boundary | Type System | Key Innovation |
+|----------|---------------------------|-------------|----------------|
+| **Quipper** | Haskell host controls quantum device | Embedded DSL, `Circ` monad | Automatic reversibility via `build_circuit` |
+| **Proto-Quipper-D** | Linear dependent types | Linear + dependent | Circuit families, type-safe uncomputation |
+| **Q#** | Integrated hybrid workflows | Domain-specific | Seamless classical-quantum integration |
+| **Qiskit** | Python orchestrates quantum circuits | Python + quantum gates | IBM hardware focus, modular architecture |
+| **Cirq** | Python controls NISQ devices | Python + quantum ops | Noise modeling for real hardware |
+| **QML** | Linear types for quantum data | Linear types | Academic, type-safe |
+| **Silq** | Automatic uncomputation | High-level, automatic | Implicit classical handling |
+| **Twist** | Entanglement types | Entanglement tracking | Purity and entanglement constraints |
+| **Qutes (2025)** | Type promotion | Classical ↔ quantum conversion | Simplified quantum programming |
+
+### Design Patterns
+
+1. **Embedded DSL in Classical Language**
+   - Quipper (Haskell), Qiskit/Cirq (Python)
+   - Classical language orchestrates quantum operations
+   - Leverages existing ecosystem
+
+2. **Monadic Quantum Operations**
+   - `Circ` monad (Quipper)
+   - Sequence quantum operations
+   - Maintains referential transparency
+
+3. **Linear Type Discipline**
+   - Proto-Quipper, QML, QWIRE
+   - Compile-time enforcement of no-cloning
+   - Explicit resource management
+
+4. **Automatic Resource Management**
+   - Silq: automatic uncomputation
+   - Qurts (2025): affine types with lifetime
+   - Reduces programmer burden
+
+---
+
+## 9. Conclusions
+
+### Key Findings
+
+1. **Quantum and classical computation cannot be trivially unified**
+   - Different categorical structures (Cartesian vs non-Cartesian)
+   - No-cloning theorem is fundamental, not technical
+   - Measurement boundary is physical, not just semantic
+
+2. **Linear type theory is essential**
+   - Enforces no-cloning at compile time
+   - Affine/linear types mirror physical constraints
+   - "Linearity" of quantum logic captures no-cloning/no-deleting
+
+3. **Categorical quantum mechanics provides rigorous foundation**
+   - Dagger compact closed categories axiomatise quantum mechanics
+   - String diagrams enable equational reasoning
+   - Complete graphical calculus (ZX-calculus)
+
+4. **Successful unification requires stratification**
+   - Classical types: Cartesian (copyable)
+   - Quantum types: Linear (non-copyable)
+   - Explicit boundary management via measurement
+   - Proto-Quipper-D as exemplar: linear dependent types
+
+5. **The measurement problem remains fundamental**
+   - Quantum (superposition, linear) → Classical (definite, nonlinear)
+   - No consensus on where boundary lies
+   - Type systems manage, not eliminate, this boundary
+
+### Implications for Type System Design
+
+**If designing a unified computational type system:**
+
+1. **Stratify** classical and quantum types
+   - Classical: standard typing rules (Cartesian structure)
+   - Quantum: linear typing rules (no duplication/deletion)
+
+2. **Dependent types** for circuit families
+   - Classical parameters index quantum data
+   - Proto-Quipper-D as reference
+
+3. **Categorical semantics**
+   - Ground in monoidal category theory
+   - Dagger structure for quantum adjoint
+   - String diagrams as syntax
+
+4. **Explicit measurement**
+   - Type: `Quantum a → M (Classical a)` (monadic)
+   - Or: `measure : Quantum a → Classical a` (side-effecting)
+   - No implicit conversions
+
+5. **Superposition not directly expressible in classical types**
+   - `|ψ⟩ = α|0⟩ + β|1⟩` requires quantum type
+   - Classical types see only measurement outcomes
+   - Amplitude information invisible to classical types
+
+### Open Questions
+
+1. **Where exactly is the quantum-classical boundary?**
+   - Measurement problem unresolved
+   - Many-worlds vs collapse interpretations
+   - Decoherence helps but doesn't fully explain collapse
+
+2. **Can we do better than linear dependent types?**
+   - Are there more expressive type systems?
+   - Can we capture more quantum properties?
+   - What about error correction at type level?
+
+3. **Infinite-dimensional quantum systems?**
+   - Dagger compact categories insufficient
+   - Need dagger symmetric monoidal categories
+   - How to handle continuous variables?
+
+4. **Automated reasoning and verification?**
+   - ZX-calculus enables automated circuit optimisation
+   - Can we prove quantum algorithms correct?
+   - Type-level verification of quantum properties?
+
+---
+
+## References
+
+### Quantum Lambda Calculus
+- Van Tonder, A. (2003). [A Lambda Calculus for Quantum Computation](https://arxiv.org/abs/quant-ph/0307150). arXiv:quant-ph/0307150.
+- Selinger, P., & Valiron, B. (2006). [A lambda calculus for quantum computation with classical control](https://arxiv.org/abs/cs/0404056). Mathematical Structures in Computer Science.
+- Review Paper (2024). [A Review of Quantum Lambda Calculi: Linearity, Semantics, and Programming Models](https://publications.eai.eu/index.php/casa/article/view/9668). EAI Transactions.
+- Lambda-SX (2025). [A Quantum-Control Lambda-Calculus with Multiple Measurement Bases](https://link.springer.com/chapter/10.1007/978-981-95-3585-9_8). APLAS 2025.
+- Qurts (2025). Qurts: Automatic Quantum Uncomputation by Affine Types with Lifetime. POPL 2025.
+
+### ZX-Calculus
+- Coecke, B., & Duncan, R. (2011). [Interacting Quantum Observables: Categorical Algebra and Diagrammatics](https://ar5iv.labs.arxiv.org/html/0906.4725). New Journal of Physics.
+- [ZX-Calculus Wikipedia](https://en.wikipedia.org/wiki/ZX-calculus)
+- [ZX graphical calculus for continuous-variable quantum processes](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.7.033141) (2025). Physical Review Research.
+- Backens, M. (2013). The ZX-Calculus for Stabilizer Quantum Mechanics. [n-Category Café](https://golem.ph.utexas.edu/category/2019/04/the_zxcalculus_for_stabilizer.html).
+
+### Linear Types and No-Cloning
+- [No-cloning theorem](https://ncatlab.org/nlab/show/no-cloning+theorem). nLab.
+- [No-cloning theorem](https://en.wikipedia.org/wiki/No-cloning_theorem). Wikipedia.
+- [Modeling Quantum Computing Constraints: No-Cloning Theorem and Monadic Expressiveness](https://sol.sbc.org.br/index.php/sblp/article/view/36952) (2024). SBLP.
+
+### Proto-Quipper and Linear Dependent Types
+- Fu, P., Kishida, K., & Selinger, P. (2020). [Linear Dependent Type Theory for Quantum Programming Languages](https://arxiv.org/abs/2004.13472). LICS 2020.
+- Fu, P., & Kishida, K. (2020). [A Tutorial Introduction to Quantum Circuit Programming in Dependently Typed Proto-Quipper](https://link.springer.com/chapter/10.1007/978-3-030-52482-1_9). Springer LNCS.
+- Proto-Quipper with Reversing and Control (2025). EPTCS.
+
+### Practical Quantum Languages
+- Green, A. S., et al. (2013). [Quipper: A Scalable Quantum Programming Language](https://arxiv.org/abs/1304.3390). PLDI 2013.
+- [The Quipper Language](https://www.mathstat.dal.ca/~selinger/quipper/). Official documentation.
+- [Quantum Programming Languages: A Beginner's Guide for 2025](https://www.bluequbit.io/quantum-programming-languages). BlueQubit.
+- [Cirq vs Qiskit vs Q#](https://quantumzeitgeist.com/cirq-vs-qiskit-vs-q-3-quantum-programming-languages-which-should-you-choose/). Quantum Zeitgeist.
+- [Introduction to Quantum Programming with Qiskit](https://blog.mlq.ai/quantum-programming-with-qiskit/). MLQ.ai.
+- Qutes (2025). [Qutes: A High-Level Quantum Programming Language](https://arxiv.org/html/2503.13084v1). arXiv.
+
+### Categorical Quantum Mechanics
+- Abramsky, S., & Coecke, B. (2004). [Categorical quantum mechanics](https://en.wikipedia.org/wiki/Categorical_quantum_mechanics). Handbook of Quantum Logic and Quantum Structures.
+- Selinger, P. (2007). [Dagger Compact Closed Categories and Completely Positive Maps](https://www.mscs.dal.ca/~selinger/papers/dagger.pdf). ENTCS.
+- [Dagger compact category](https://en.wikipedia.org/wiki/Dagger_compact_category). Wikipedia.
+- [Quantum information theory via dagger-compact categories](https://ncatlab.org/nlab/show/quantum+information+theory+via+dagger-compact+categories). nLab.
+- Duncan, R., & Perdrix, S. (2018). [Dagger linear logic for categorical quantum mechanics](https://arxiv.org/abs/1809.00275). arXiv.
+
+### Measurement and Quantum-Classical Boundary
+- [Measurement problem](https://en.wikipedia.org/wiki/Measurement_problem). Wikipedia.
+- [Wave function collapse](https://en.wikipedia.org/wiki/Wave_function_collapse). Wikipedia.
+- [Quantum decoherence](https://en.wikipedia.org/wiki/Quantum_decoherence). Wikipedia.
+- Bassi, A., et al. (2023). [Collapse Models: A Theoretical, Experimental and Philosophical Review](https://www.mdpi.com/1099-4300/25/4/645). Entropy.
+
+### Unification Approaches
+- [Typing Quantum Superpositions and Measurement](https://link.springer.com/chapter/10.1007/978-3-319-71069-3_22) (2017). Springer LNCS.
+- Feng, Y. (2013). [An Axiomatization for Quantum Processes to Unifying Quantum and Classical Computing](https://ar5iv.labs.arxiv.org/html/1311.2960). arXiv.
+- [Homotopy Type Theory and Computing — Classical and Quantum](https://nyuad.nyu.edu/en/events/2024/april/homotopy-type-theory-and-computing.html) (2024). NYU Abu Dhabi Conference.
+
+### Quantum Superposition and Computing Basics
+- [Quantum Superposition](https://postquantum.com/quantum-computing/quantum-superposition/). PostQuantum.
+- [Microsoft Quantum: Superposition](https://quantum.microsoft.com/en-us/insights/education/concepts/superposition). Microsoft.
+- [Quantum computing](https://en.wikipedia.org/wiki/Quantum_computing). Wikipedia.
+
+---
+
+## Appendix: Key Concepts Glossary
+
+**Affine Types:** Types that must be used **at most once** (can be discarded, not duplicated).
+
+**Bell States:** Maximally entangled quantum states of two qubits.
+
+**Choi-Jamiołkowski Isomorphism:** Process-state duality - correspondence between quantum channels and density matrices.
+
+**Clifford Fragment:** Subset of quantum operations generated by Hadamard, CNOT, and phase gates (stabiliser operations).
+
+**Compact Closed Category:** Monoidal category where every object has a dual, enabling "bending wires" in diagrams.
+
+**Dagger Category:** Category with a contravariant functor †: C^op → C that is identity on objects and involutive.
+
+**Dagger Compact Category:** Category that is both dagger and compact closed.
+
+**Frobenius Algebra:** Algebraic structure with compatible multiplication and comultiplication satisfying Frobenius law.
+
+**Linear Types:** Types that must be used **exactly once** (neither duplicated nor discarded).
+
+**Monoidal Category:** Category with tensor product ⊗ and unit object satisfying coherence axioms.
+
+**NISQ:** Noisy Intermediate-Scale Quantum - current era of quantum computers (50-1000 qubits, significant noise).
+
+**String Diagrams:** Graphical notation for morphisms in monoidal categories, read compositionally.
+
+**Unitary Operation:** Quantum operation U where U†U = UU† = I (preserves inner products, reversible).
+
+**ZX-Spider:** Generator in ZX-calculus representing a multi-input, multi-output node with a phase.

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.8.10",
+  "version": "0.9.0",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "claudetools": "dist/cli.js"
+    "claudetools": "dist/cli.js",
+    "kappa": "dist/codedna/kappa-cli.js"
   },
   "files": [
     "dist",
@@ -60,6 +61,7 @@
     "@modelcontextprotocol/sdk": "^1.0.0",
     "better-sqlite3": "^12.5.0",
     "chalk": "^5.6.2",
+    "chevrotain": "^11.0.3",
     "nunjucks": "^3.2.4",
     "ora": "^9.0.0",
     "prompts": "^2.4.2",