quantum-spherifier 1.0.0

package/research/topics/molecular_simulation/seed_femoco_2026/main.tex

@@ -0,0 +1,119 @@
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage[margin=1in]{geometry}
+
+\title{FeMoco Simulation: The Canonical Quantum Chemistry Target and Its Resource Requirements (2026)}
+\author{quantum-spherifier (:qSpherifier) Seed Document \\ Research Line: Molecular Simulation}
+\date{2026}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+The iron-molybdenum cofactor (FeMoco) of the nitrogenase enzyme is the canonical ``killer app'' target for quantum chemistry on a fault-tolerant quantum computer. Classical methods (DFT, CASSCF, DMRG) struggle with the strongly correlated $3d$ electrons of the seven-iron cluster, and the mechanism of biological nitrogen fixation remains an open problem. This document reviews the FeMoco challenge, presents the state-of-the-art resource estimates (Reiher et al.\ 2017; Goings et al.\ 2022), and maps the path from current 100-qubit NISQ experiments to the $\sim 3{,}000$-logical-qubit, $\sim 10^{10}$-$T$-gate fault-tolerant computation needed for chemical accuracy.
+\end{abstract}
+
+\section{The FeMoco Challenge}
+
+\subsection{Why FeMoco?}
+FeMoco is the active site of nitrogenase, the enzyme that catalyzes the reduction of atmospheric nitrogen to ammonia ($\text{N}_2 + 8\text{H}^+ + 8\text{e}^- \to 2\text{NH}_3 + \text{H}_2$) at ambient temperature and pressure. The industrial Haber--Bosch process that performs the same reaction consumes $\sim 1$--$2\%$ of global energy production. Understanding the FeMoco mechanism could enable energy-efficient catalysts for fertilizer production---a problem with direct civilisational impact.
+
+\subsection{Electronic Structure}
+FeMoco consists of a Mo$_7$Fe$_7$S$_9$C cluster with:
+\begin{itemize}
+  \item 7 iron atoms, each with $3d$ electrons that are strongly correlated.
+  \item A central carbide (C$^{4-}$) interstitial.
+  \item Total active space: $\sim 54$--$154$ spin-orbitals (depending on the active-space truncation).
+  \item Near-degenerate $d$-orbital manifold causing multi-reference character.
+\end{itemize}
+
+\subsection{Classical Difficulty}
+\begin{itemize}
+  \item \textbf{DFT}: Functionals fail for strongly correlated $3d$ electrons; errors of 10+ kcal/mol.
+  \item \textbf{CCSD(T)}: Breaks down for multi-reference systems.
+  \item \textbf{DMRG}: Can treat $\sim 50$--$100$ orbitals but at exponential cost in bond dimension; struggles with dynamic correlation.
+  \item \textbf{CASPT2/NEVPT2}: Require a CAS reference; limited to $\sim 20$ active electrons in 20 orbitals.
+\end{itemize}
+No classical method achieves chemical accuracy ($\sim 1$\,kcal/mol $\approx 1.6$\,mHa) for FeMoco.
+
+\section{Resource Estimates for Quantum Simulation}
+
+\subsection{Reiher et al.\ (2017) Estimate}
+The seminal Reiher et al.\ study estimated the resources for FeMoco ground-state energy via quantum phase estimation:
+\begin{itemize}
+  \item Active orbitals: 54
+  \item Logical qubits: $\sim 2{,}000$ (data + ancilla)
+  \item $T$-gate count: $\sim 10^{10}$
+  \item Physical qubits (surface code, $d = 31$): $\sim 10^6$
+  \item Runtime: hours to days
+\end{itemize}
+
+\subsection{Goings et al.\ (2022) Refined Estimate}
+Using improved basis sets and qubitization:
+\begin{itemize}
+  \item Active orbitals: 154 (larger basis for chemical accuracy)
+  \item Hamiltonian 1-norm: $\lambda \approx 1{,}511$
+  \item Logical qubits: $\sim 3{,}000$--$4{,}000$
+  \item $T$-gate count: $\sim 10^{10}$--$10^{11}$
+  \item Physical qubits (surface code, $d = 25$): $\sim 4 \times 10^6$
+  \item Runtime: $\sim 4$ days at 25\,MHz $T$-gate clock
+\end{itemize}
+
+\section{Algorithmic Choices}
+
+\subsection{Quantum Phase Estimation (QPE)}
+QPE is the gold standard for ground-state energy on a fault-tolerant quantum computer. It requires:
+\begin{itemize}
+  \item An initial state with non-trivial overlap with the ground state (Hartree--Fock or VQE-prepared).
+  \item Controlled time-evolution $e^{-iHt}$ implemented via qubitization or Trotterization.
+  \item Inverse QFT for readout.
+\end{itemize}
+
+\subsection{Qubitization vs.\ Trotterization}
+\begin{itemize}
+  \item \textbf{Trotterization}: $T$-count $\sim N^4 t^2 / \epsilon$; simple to implement but high cost.
+  \item \textbf{Qubitization (QSVT)}: $T$-count $\sim 3 \lambda N \log(1/\epsilon)$; optimal query complexity; $\sim 100\times$ fewer $T$-gates than Trotter for FeMoco.
+\end{itemize}
+Qubitization is the algorithm of choice for fault-tolerant FeMoco simulation.
+
+\subsection{Fermion-to-Qubit Mapping}
+\begin{itemize}
+  \item \textbf{Jordan--Wigner}: Simple; $O(N)$-length Pauli strings; high overhead on 2D-lattice hardware.
+  \item \textbf{Bravyi--Kitaev}: $O(\log N)$-length strings; lower overhead for large $N$.
+  \item \textbf{Symmetry tapering}: Exploits $S_z$, particle-number, and time-reversal symmetries to reduce qubit count by 4--8.
+\end{itemize}
+
+\section{Near-Term Stepping Stones}
+
+\subsection{NISQ-Era VQE on Reduced Active Spaces}
+Before fault-tolerant FeMoco is possible, NISQ-era VQE on reduced active spaces (10--30 orbitals) can:
+\begin{itemize}
+  \item Validate quantum chemistry workflows on real hardware.
+  \item Benchmark ans\"atze (UCCSD, k-UpCCGSD, ADAPT-VQE) against classical references.
+  \item Identify which FeMoco subspaces are most strongly correlated.
+\end{itemize}
+IBM Heron (156 qubits) and Quantinuum H2 (56 qubits) are suitable platforms.
+
+\subsection{Transition-Metal Catalysts as Intermediate Targets}
+Smaller transition-metal complexes (Ni, Cu, Fe catalysts for C--H activation, cross-coupling) are tractable on 50--200-logical-qubit processors and have direct pharmaceutical relevance. These serve as stepping stones to full FeMoco.
+
+\section{Cross-Links to Other Research Lines}
+
+\begin{itemize}
+  \item \textbf{QEC}: FeMoco requires $\sim 3{,}000$ logical qubits $\approx 3$--$4$ million physical qubits (surface code). qLDPC codes on neutral atoms could reduce this to $\sim 300$K--1M. See \textit{Surface-Code QEC Seed Document}.
+  \item \textbf{New Qubit Modalities}: Long-coherence neutral-atom qubits (40\,s $T_1$) relax the QEC cycle-time constraint, enabling deeper logical circuits. See \textit{Neutral-Atom Seed Document}.
+  \item \textbf{Quantum Algorithms}: QSVT-based qubitization is the optimal algorithm for FeMoco, requiring $\sim 100\times$ fewer $T$-gates than Trotterization. See \textit{QSVT Seed Document}.
+\end{itemize}
+
+\section*{References}
+\begin{itemize}
+  \item Reiher, Wiebe, Svore, Wecker, Troyer, ``Elucidating reaction mechanisms on quantum computers,'' \textit{PNAS} 114, 7555 (2017).
+  \item Goings et al., ``Reliably assessing the electronic structure of cytochrome P450 on today's classical computers and tomorrow's quantum computers,'' \textit{PNAS} 119, e2203533119 (2022).
+  \item Babbush et al., ``Encoding electronic spectra in quantum circuits with linear $T$ complexity,'' \textit{Quantum} 2, 44 (2018).
+  \item Lee et al., ``Even more efficient quantum computations of chemistry through tensor hypercontraction,'' \textit{PRX Quantum} 2, 020305 (2021).
+\end{itemize}
+
+\end{document}

package/research/topics/molecular_simulation/seed_femoco_2026/manifest.json

@@ -0,0 +1,20 @@
+{
+  "id": "seed_femoco_2026",
+  "version": "1.0",
+  "title": "FeMoco Simulation: The Canonical Quantum Chemistry Target and Its Resource Requirements (2026)",
+  "category": "topics",
+  "topic": "molecular_simulation",
+  "researchLine": "molecular_simulation",
+  "tags": ["molecular_simulation", "femoco", "baseline_knowledge", "cross_linked"],
+  "references": ["sim_femoco", "sim_fermionic_hamiltonian", "sim_qubitization", "algo_qpe"],
+  "crossLinks": [
+    { "to": "seed_surface_code_2026", "relationship": "related" },
+    { "to": "seed_neutral_atom_2026", "relationship": "related" },
+    { "to": "seed_qsvt_2026", "relationship": "builds_on" }
+  ],
+  "patent": { "eligible": false, "claims": [] },
+  "createdAt": 1735689600000,
+  "updatedAt": 1735689600000,
+  "extra": { "seed": true, "description": "Baseline knowledge document for the Molecular Simulation line" },
+  "files": { "latex": "main.tex" }
+}

package/research/topics/qec/seed_surface_code_2026/main.tex

@@ -0,0 +1,89 @@
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage[margin=1in]{geometry}
+
+\title{Surface-Code Quantum Error Correction: State of the Art and Path to Fault Tolerance (2026)}
+\author{quantum-spherifier (:qSpherifier) Seed Document \\ Research Line: Quantum Error Correction}
+\date{2026}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+The surface code is the leading quantum error-correcting (QEC) code for superconducting and neutral-atom qubit platforms. As of 2026, Google's Willow processor has demonstrated exponential error suppression below the surface-code threshold at code distance 7, marking the first experimental confirmation of the threshold theorem for a real quantum processor. This document reviews the current state, identifies the key bottlenecks (overhead, magic-state distillation, decoder latency), and outlines the path from 1 logical qubit (today) to 100 logical qubits (2028--2030) and ultimately to 4,000 logical qubits needed for RSA-2048 factoring (2035+).
+\end{abstract}
+
+\section{Current State (2026)}
+
+\subsection{The Threshold Theorem in Practice}
+The threshold theorem states that if the physical error rate $p$ is below a critical threshold $p_{\text{th}}$, the logical error rate $p_L$ can be suppressed arbitrarily by increasing the code distance $d$. For the surface code under circuit-level depolarizing noise, $p_{\text{th}} \approx 1\%$. The logical error rate scales as:
+
+\begin{equation}
+p_L \approx A \left( \frac{p}{p_{\text{th}}} \right)^{(d+1)/2}
+\end{equation}
+
+where $A \approx 0.1$. Google's Willow chip (December 2024) verified this scaling experimentally at $d = 7$, achieving a logical error rate lower than at $d = 5$---the first below-threshold demonstration.
+
+\subsection{Hardware Anchors}
+\begin{itemize}
+  \item \textbf{Google Willow} (105 qubits): distance-7 surface code, 2-qubit gate fidelity 99.8\%, exponential error suppression confirmed.
+  \item \textbf{IBM Heron R2} (156 qubits, tunable couplers): 2-qubit gate fidelity 99.7\%; basis for IBM's modular QEC roadmap.
+  \item \textbf{Quantinuum H2} (56 trapped ions): 99.87\% 2-qubit fidelity; demonstrated non-Abelian topological states and magic-state distillation.
+  \item \textbf{Atom Computing} (1,180 neutral atoms): largest qubit count; reconfigurable geometry ideal for QEC.
+\end{itemize}
+
+\section{Key Bottlenecks}
+
+\subsection{Physical-to-Logical Overhead}
+The surface code requires $\sim 2d^2$ physical qubits per logical qubit. For a target logical error rate of $10^{-9}$ (required for deep circuits like Shor's algorithm), with physical error $p = 10^{-3}$, the required code distance is $d \approx 21$, giving $\sim 882$ physical qubits per logical qubit. With magic-state factories (needed for universal computation), the total overhead reaches $\sim 1{,}000\times$. This means 4,000 logical qubits for RSA-2048 require $\sim 4$ million physical qubits.
+
+\subsection{Magic-State Distillation}
+Universal fault-tolerant computation requires $T$-gates, which cannot be implemented transversally in the surface code. The standard Bravyi--Kitaev 15-to-1 distillation protocol consumes 15 noisy $T$-states to produce 1 high-fidelity $T$-state, at a cost of $\sim 12d^2$ physical qubits per factory. For deep circuits ($10^9$+ $T$-gates), the factory footprint dominates the processor.
+
+\subsection{Decoder Latency}
+Real-time decoding is essential: syndromes must be decoded within one QEC cycle ($\sim 1\,\mu$s for superconducting qubits). Minimum-weight perfect matching (MWPM) scales as $O(d^2)$ per cycle; neural-network decoders offer lower latency but require training and lack formal guarantees.
+
+\section{Path to Fault Tolerance}
+
+\subsection{Near-Term (2026--2028): 1--10 Logical Qubits}
+\begin{itemize}
+  \item Extend Willow's distance-7 result to $d = 11$--$15$ on 200--500-qubit processors.
+  \item Demonstrate magic-state distillation on a logical qubit.
+  \item Implement a single logical-qubit memory with $p_L < 10^{-6}$.
+\end{itemize}
+
+\subsection{Mid-Term (2028--2033): 100--1,000 Logical Qubits}
+\begin{itemize}
+  \item Modular architectures: connect multiple 1,000-physical-qubit chips via quantum interconnects.
+  \item qLDPC codes on reconfigurable platforms (neutral atoms) to reduce overhead from $O(d^2)$ to $O(1)$.
+  \item First useful quantum chemistry simulation (FeMoco-scale) on 100--300 logical qubits.
+\end{itemize}
+
+\subsection{Long-Term (2033--2040): 4,000+ Logical Qubits}
+\begin{itemize}
+  \item RSA-2048 factoring (requires $\sim 4{,}000$ logical qubits, $\sim 10^{10}$ $T$-gates).
+  \item Full-scale FeMoco simulation with chemical accuracy.
+  \item Practical quantum advantage in optimization and machine learning.
+\end{itemize}
+
+\section{Cross-Links to Other Research Lines}
+
+This document is not isolated. It cross-links to:
+\begin{itemize}
+  \item \textbf{New Qubit Modalities}: Surface-code viability depends on qubit modality (transmon, neutral atom, trapped ion). Neutral atoms with reconfigurable geometry are natural for qLDPC codes.
+  \item \textbf{Quantum Algorithms}: Shor's algorithm and QPE require $\sim 4{,}000$ and $\sim 200$--$3{,}000$ logical qubits respectively, directly driving QEC requirements.
+  \item \textbf{Molecular Simulation}: FeMoco simulation requires $\sim 3{,}000$ logical qubits and $\sim 10^{11}$ $T$-gates; the QEC overhead is the dominant cost.
+\end{itemize}
+
+\section*{References}
+\begin{itemize}
+  \item Acharya et al., ``Quantum error correction below the surface code threshold,'' \textit{Nature} (2024). [Google Willow]
+  \item Fowler et al., ``Surface codes: Towards practical large-scale quantum computation,'' \textit{Phys. Rev. A} 86, 032324 (2012).
+  \item Bravyi \& Kitaev, ``Universal quantum computation with ideal Clifford gates and noisy ancillas,'' \textit{Phys. Rev. A} 71, 022316 (2005).
+  \item Gidney \& Eker\r{a}, ``How to factor 2048-bit RSA integers in 8 hours using 20 million noisy qubits,'' \textit{Quantum} 5, 433 (2021).
+\end{itemize}
+
+\end{document}

package/research/topics/qec/seed_surface_code_2026/manifest.json

@@ -0,0 +1,20 @@
+{
+  "id": "seed_surface_code_2026",
+  "version": "1.0",
+  "title": "Surface-Code Quantum Error Correction: State of the Art and Path to Fault Tolerance (2026)",
+  "category": "topics",
+  "topic": "qec",
+  "researchLine": "quantum_error_correction",
+  "tags": ["qec", "surface_code", "baseline_knowledge", "cross_linked"],
+  "references": ["qec_surface_code", "qec_measurement_results", "qec_magic_state_distillation", "hw_google_willow"],
+  "crossLinks": [
+    { "to": "seed_neutral_atom_2026", "relationship": "builds_on" },
+    { "to": "seed_qsvt_2026", "relationship": "related" },
+    { "to": "seed_femoco_2026", "relationship": "related" }
+  ],
+  "patent": { "eligible": false, "claims": [] },
+  "createdAt": 1735689600000,
+  "updatedAt": 1735689600000,
+  "extra": { "seed": true, "description": "Baseline knowledge document for the QEC research line" },
+  "files": { "latex": "main.tex" }
+}

package/research/topics/qubits/seed_neutral_atom_2026/main.tex

@@ -0,0 +1,98 @@
+\documentclass[11pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{hyperref}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage[margin=1in]{geometry}
+
+\title{Neutral-Atom Qubit Modalities: Scalability, Coherence, and QEC Compatibility (2026)}
+\author{quantum-spherifier (:qSpherifier) Seed Document \\ Research Line: New Qubit Modalities}
+\date{2026}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+Neutral-atom quantum computing has emerged as a leading modality for scalable quantum information processing. As of 2026, Atom Computing has demonstrated 1,180 strontium neutral-atom qubits with 40-second coherence, and QuEra's Aquila (256 rubidium atoms) is available via AWS Braket. The reconfigurable geometry of optical-tweezer arrays---unique to neutral atoms---enables all-to-all connectivity via Rydberg blockade and makes this platform a natural fit for quantum low-density parity-check (qLDPC) codes with non-local check measurements. This document reviews the state of the art, compares neutral atoms to superconducting and trapped-ion alternatives, and identifies the path to 10,000+ qubit fault-tolerant processors.
+\end{abstract}
+
+\section{Current State (2026)}
+
+\subsection{Hardware Anchors}
+\begin{itemize}
+  \item \textbf{Atom Computing} (1,180 strontium atoms): first platform to exceed 1,000 qubits; nuclear-spin qubits with $T_1 \approx 40$\,s; 2-qubit gate fidelity $\approx 99.5\%$.
+  \item \textbf{QuEra Aquila} (256 rubidium atoms): programmable analog quantum simulator available via AWS Braket; Rydberg blockade gates.
+  \item \textbf{Pascal (Pasqal)} (324 rubidium atoms): analog and digital modes; quantum processing service in Europe.
+\end{itemize}
+
+\subsection{Qubit Encoding}
+Neutral-atom qubits are encoded in either:
+\begin{enumerate}
+  \item \textbf{Hyperfine ground states} (e.g., $^{87}$Rb $|F=1, m_F=0\rangle$ and $|F=2, m_F=0\rangle$): clock states with long coherence ($T_2 > 1$\,s).
+  \item \textbf{Nuclear-spin states} (e.g., $^{87}$Sr or $^{171}$Yb): decoupled from electronic noise, achieving $T_1 \approx 40$\,s in strontium.
+\end{enumerate}
+
+\section{Advantages of Neutral Atoms}
+
+\subsection{Scalability}
+Optical-tweezer arrays can trap thousands of atoms in 2D or 3D geometries. Unlike superconducting qubits (which require individual microwave control lines) or trapped ions (which require individual addressing in a shared trap), neutral-atom arrays are loaded stochastically and rearranged deterministically. Atom Computing's 1,180-site array demonstrates that the loading-and-rearrangement protocol scales to kilo-qubit counts.
+
+\subsection{Reconfigurable Geometry}
+The unique advantage of neutral atoms is that the tweezer array geometry is software-defined. Atoms can be moved between gate cycles, enabling:
+\begin{itemize}
+  \item \textbf{All-to-all connectivity}: any pair of atoms can be brought into Rydberg blockade range.
+  \item \textbf{Non-local QEC checks}: qLDPC codes require long-range parity checks that are prohibitively expensive on fixed-lattice superconducting processors but trivial on neutral atoms.
+  \item \textbf{Dynamic code switching}: the same physical qubits can be reconfigured from a surface-code layout to a color-code or qLDPC layout between algorithmic subroutines.
+\end{itemize}
+
+\subsection{Coherence}
+Nuclear-spin qubits in group-II atoms (Sr, Yb) achieve $T_1$ and $T_2$ in the 10--60\,s range---orders of magnitude longer than superconducting transmons ($T_1 \sim 300\,\mu$s). This relaxes the decoder-latency constraint and enables deeper logical circuits.
+
+\section{Challenges}
+
+\subsection{Gate Fidelity}
+Two-qubit gate fidelity for neutral atoms ($\sim 99.5\%$) lags behind trapped ions ($\sim 99.9\%$) and the best superconducting qubits ($\sim 99.8\%$). The dominant error sources are:
+\begin{itemize}
+  \item Rydberg laser intensity noise (causing phase errors).
+  \item Atomic motion during gates (Doppler dephasing).
+  \item Finite Rydberg blockade radius (imperfect blockade for distant atoms).
+\end{itemize}
+
+\subsection{Gate Speed}
+Rydberg-mediated gates are slow ($\sim 1\,\mu$s for 1-qubit, $\sim 5\,\mu$s for 2-qubit) compared to superconducting gates ($\sim 20$\,ns and $\sim 200$\,ns). This limits the circuit depth achievable within the coherence time, though the long $T_1$ partially compensates.
+
+\subsection{Atom Loss}
+Atoms are stochastically lost from tweezers at a rate of $\sim 10^{-3}$ per second. For deep circuits, this requires either mid-circuit reloading or heralded-loss-tolerant protocols.
+
+\section{Path to 10,000+ Qubits}
+
+\subsection{Near-Term (2026--2028)}
+\begin{itemize}
+  \item Improve 2-qubit gate fidelity to 99.9\% via pulse shaping and dynamical decoupling.
+  \item Demonstrate distance-7 surface code on a neutral-atom processor.
+  \item Scale to 5,000+ atoms with automated rearrangement.
+\end{itemize}
+
+\subsection{Mid-Term (2028--2032)}
+\begin{itemize}
+  \item Implement qLDPC codes exploiting reconfigurable geometry (constant-rate encoding, 10$\times$ overhead reduction vs.\ surface code).
+  \item Modular neutral-atom processors linked by photonic interconnects.
+  \item First fault-tolerant logical-qubit operations on 100+ logical qubits.
+\end{itemize}
+
+\section{Cross-Links to Other Research Lines}
+
+\begin{itemize}
+  \item \textbf{QEC}: Neutral atoms are the natural platform for qLDPC codes (non-local checks) and Bacon-Shor codes (biased noise). See \textit{Surface-Code QEC Seed Document}.
+  \item \textbf{Algorithms}: Long coherence enables deep circuits (QPE, Trotterization) with relaxed QEC requirements.
+  \item \textbf{Molecular Simulation}: 10,000+ physical qubits with qLDPC overhead reduction could bring FeMoco simulation from 1M physical qubits (surface code) down to $\sim$100K physical qubits.
+\end{itemize}
+
+\section*{References}
+\begin{itemize}
+  \item Bluvstein et al., ``Logical quantum processor based on reconfigurable atom arrays,'' \textit{Nature} 626, 58--65 (2024).
+  \item Evered et al., ``High-fidelity parallel entangling gates on a neutral-atom quantum computer,'' \textit{Nature} 622, 268--272 (2023).
+  \item Graham et al., ``Multi-qubit entanglement and algorithms on a neutral-atom quantum computer,'' \textit{Nature} 604, 457--462 (2022).
+\end{itemize}
+
+\end{document}

package/research/topics/qubits/seed_neutral_atom_2026/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "seed_neutral_atom_2026",
+  "version": "1.0",
+  "title": "Neutral-Atom Qubit Modalities: Scalability, Coherence, and QEC Compatibility (2026)",
+  "category": "topics",
+  "topic": "qubits",
+  "researchLine": "new_qubit_modalities",
+  "tags": ["qubits", "neutral_atom", "baseline_knowledge", "cross_linked"],
+  "references": ["qubit_neutral_atom", "hw_atom_computing", "hw_quera_aquila"],
+  "crossLinks": [
+    { "to": "seed_surface_code_2026", "relationship": "builds_on" },
+    { "to": "seed_femoco_2026", "relationship": "related" }
+  ],
+  "patent": { "eligible": false, "claims": [] },
+  "createdAt": 1735689600000,
+  "updatedAt": 1735689600000,
+  "extra": { "seed": true, "description": "Baseline knowledge document for the New Qubit Modalities line" },
+  "files": { "latex": "main.tex" }
+}

package/scripts/benchmark.js

@@ -0,0 +1,56 @@
+/**
+ * benchmark.js — quantum-spherifier (v1.0)
+ * Quick performance benchmark of the core modules.
+ */
+
+import { ArtificialJunkyNeuron } from '../src/core/ArtificialJunkyNeuron.js';
+import { ANNPsi } from '../src/core/ANNPsi.js';
+import { QuantumPhysicsTool } from '../src/tools/QuantumPhysicsTool.js';
+
+const ITERATIONS = 1000;
+
+console.log(`\n=== quantum-spherifier v1.0 — benchmark (${ITERATIONS} iterations) ===\n`);
+
+// 1. AJN throughput
+console.log('1. AJN single-neuron throughput:');
+const ajn = new ArtificialJunkyNeuron({ stimulusClass: 'qubit_transmon' });
+const t0 = performance.now();
+for (let i = 0; i < ITERATIONS; i++) {
+  ajn.process({ intensity: Math.random() });
+}
+const dt = performance.now() - t0;
+console.log(`   ${ITERATIONS} steps in ${dt.toFixed(1)} ms → ${(ITERATIONS / dt * 1000).toFixed(0)} steps/s\n`);
+
+// 2. ANN-Psi forward pass
+console.log('2. ANN-Psi 14-layer forward pass:');
+const ann = new ANNPsi({ dModel: 256, nHeads: 8, dFF: 1024 });
+const t1 = performance.now();
+for (let i = 0; i < 100; i++) {
+  ann.forward({ intensity: 0.5, vector: new Float64Array(256) });
+}
+const dt2 = performance.now() - t1;
+console.log(`   100 forward passes in ${dt2.toFixed(1)} ms → ${(100 / dt2 * 1000).toFixed(0)} passes/s\n`);
+
+// 3. Quantum physics calculations
+console.log('3. Quantum physics (surface code + Shor resources):');
+const qp = new QuantumPhysicsTool();
+const t2 = performance.now();
+let dummy = 0;
+for (let i = 0; i < ITERATIONS; i++) {
+  const r = qp.execute({ operation: 'surface_code_error', params: { physicalErrorRate: 0.005 + i * 0.00001, codeDistance: 7 + (i % 5) } });
+  if (r.ok) dummy += r.result.logicalErrorRate ?? 0;
+}
+const dt3 = performance.now() - t2;
+console.log(`   ${ITERATIONS} surface-code evals in ${dt3.toFixed(1)} ms → ${(ITERATIONS / dt3 * 1000).toFixed(0)} evals/s`);
+console.log(`   (sanity check: dummy sum = ${dummy.toExponential(3)})\n`);
+
+// 4. Shor resource estimation
+console.log('4. Shor RSA resource estimation:');
+const t3 = performance.now();
+for (let i = 0; i < 100; i++) {
+  qp.execute({ operation: 'shor_resources', params: { rsaBits: 1024 + i * 8, codeDistance: 21 } });
+}
+const dt4 = performance.now() - t3;
+console.log(`   100 Shor estimates in ${dt4.toFixed(1)} ms\n`);
+
+console.log('=== benchmark complete ===\n');

package/scripts/cli.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+/**
+ * quantum-spherifier CLI — v1.0
+ *
+ * Commands:
+ *   research             Run autonomous research (default)
+ *   guide "<directive>"  Send an owner directive to the running agent
+ *   web                  Start the web dashboard
+ *   demo                 Run a 3-cycle demo
+ *   train                Run the 4-phase training pipeline
+ *   checkpoint save|list|load
+ *   patents              List patent-eligible documents
+ *   clusters             List patent clusters
+ *   archive              Rebuild archive indices
+ *   status               Print agent status snapshot
+ *   kg                   Print knowledge graph stats
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createQSpherifier } from '../src/index.js';
+import { StateSerializer } from '../src/core/StateSerializer.js';
+
+const program = new Command();
+
+program
+  .name('qspherifier')
+  .description('quantum-spherifier (qSpherifier) v1.0 — Autonomous Quantum Computing Research Agent')
+  .version('1.0.0');
+
+program
+  .command('research')
+  .description('Run autonomous research (default mode)')
+  .option('-c, --cycles <n>', 'maximum cycles', '50')
+  .option('-s, --safety <level>', 'safety level (permissive|standard|strict)', 'standard')
+  .option('--no-autonomous', 'wait for explicit owner directives')
+  .action(async (opts) => {
+    const spinner = ora('Initialising quantum-spherifier...').start();
+    const agent = await createQSpherifier({
+      maxCycles: parseInt(opts.cycles, 10),
+      safetyLevel: opts.safety,
+      autonomousMode: opts.autonomous !== false,
+    });
+    spinner.succeed(`quantum-spherifier online — agent ${agent.id}`);
+    console.log(chalk.cyan('\n  Mission: Quantum computers that solve impossible problems.'));
+    console.log(chalk.gray('  Lines: QEC · New Qubits · Algorithms · Molecular Simulation'));
+    console.log(chalk.gray('  Press Ctrl+C to stop.\n'));
+
+    agent.on('cycle:start', ({ count }) => {
+      console.log(chalk.blue(`\n[Cycle ${count}] starting...`));
+    });
+    agent.on('routed', (r) => {
+      const lineLabel = r.line?.replace(/_/g, ' ') ?? 'unknown';
+      console.log(chalk.gray(`  → Routed to: ${lineLabel}${r.crossLink ? ` (cross-link with ${r.pairedLine?.replace(/_/g,' ')})` : ''}`));
+    });
+    agent.on('hypothesis:generated', (h) => {
+      console.log(chalk.green('  ✓ Hypothesis generated:'));
+      console.log(chalk.white(`    ${h.statement?.slice(0, 140) ?? '(no statement)'}`));
+      console.log(chalk.gray(`    Feasibility: ${h.feasibility?.tier ?? 'unknown'} (conf ${h.feasibility?.confidence ?? 'n/a'})`));
+      console.log(chalk.gray(`    Cross-links: ${(h.supportingConcepts ?? []).length} KG concepts`));
+    });
+    agent.on('patent:drafted', (p) => {
+      console.log(chalk.magenta('  ✓ Patent draft:'));
+      console.log(chalk.white(`    ${p.title}`));
+      console.log(chalk.gray(`    ${p.claims?.length ?? 0} claims`));
+    });
+    agent.on('document:archived', (r) => {
+      console.log(chalk.gray(`  → Archived: ${r.manifest.category}/${r.manifest.topic}/${r.manifest.id}`));
+    });
+    agent.on('clusters:filing_ready', (clusters) => {
+      console.log(chalk.yellow.bold(`  ★ ${clusters.length} filing-ready patent cluster(s)!`));
+    });
+    agent.on('cycle:error', ({ error }) => {
+      console.log(chalk.red(`  ✗ Cycle error: ${error}`));
+    });
+
+    setInterval(() => {}, 1000);
+  });
+
+program
+  .command('guide <directive>')
+  .description('Send an owner directive to the running agent')
+  .action(async (directive) => {
+    const agent = await createQSpherifier({ maxCycles: 5 });
+    console.log(chalk.cyan(`Sending directive: "${directive}"`));
+    const r = await agent.guide(directive);
+    console.log(chalk.green('Directive accepted:'));
+    console.log(JSON.stringify(r, null, 2));
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('web')
+  .description('Start the web dashboard (port 3000)')
+  .action(async () => {
+    await import('../web/server.js');
+  });
+
+program
+  .command('demo')
+  .description('Run a 3-cycle demo')
+  .action(async () => {
+    const spinner = ora('Booting quantum-spherifier demo...').start();
+    const agent = await createQSpherifier({ maxCycles: 3, autonomousMode: false });
+    spinner.succeed('Demo ready');
+    for (let i = 0; i < 3; i++) {
+      console.log(chalk.blue(`\n=== Demo cycle ${i + 1} ===`));
+      await agent._runCycle();
+    }
+    const stats = agent.archivist.stats();
+    console.log(chalk.green('\n=== Demo complete ==='));
+    console.log(chalk.white(`  Documents produced: ${stats.total}`));
+    console.log(chalk.white(`  Patent-eligible: ${stats.patentEligible}`));
+    console.log(chalk.white(`  Cross-linked: ${stats.crossLinked}`));
+    console.log(chalk.white(`  KG nodes: ${agent.kg.nodes.size}, edges: ${agent.kg.edges.size}`));
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('train')
+  .description('Run the 4-phase training pipeline')
+  .action(async () => {
+    const agent = await createQSpherifier({ autonomousMode: false });
+    const { TrainingPipeline } = await import('../src/training/TrainingPipeline.js');
+    const pipeline = new TrainingPipeline({ agent });
+    await pipeline.run();
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('checkpoint <action>')
+  .description('save | list | load a checkpoint')
+  .option('--label <label>', 'checkpoint label')
+  .option('--id <id>', 'checkpoint id')
+  .action(async (action, opts) => {
+    const agent = await createQSpherifier({ autonomousMode: false });
+    const serializer = new StateSerializer({});
+    if (action === 'save') {
+      const r = await serializer.save(agent, opts.label ?? 'manual');
+      console.log(chalk.green(`Saved: ${r.filepath}`));
+    } else if (action === 'list') {
+      const list = serializer.list();
+      console.log(chalk.cyan(`Checkpoints (${list.length}):`));
+      for (const c of list) console.log(`  ${c.timestamp}  ${c.label}`);
+    } else if (action === 'load') {
+      const r = await serializer.load(agent, opts.id ?? opts.label);
+      if (r) console.log(chalk.green(`Loaded: ${r.label}`));
+      else console.log(chalk.red('Not found'));
+    } else {
+      console.log(chalk.red(`Unknown action: ${action}`));
+    }
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('patents')
+  .description('List patent-eligible documents')
+  .action(async () => {
+    const agent = await createQSpherifier({ autonomousMode: false });
+    const queue = agent.archivist.patentQueue();
+    if (queue.length === 0) {
+      console.log(chalk.yellow('No patent-eligible documents yet.'));
+    } else {
+      console.log(chalk.cyan(`Patent queue (${queue.length}):`));
+      for (const r of queue) {
+        const m = r.manifest;
+        console.log(chalk.white(`  ${m.title}`));
+        console.log(chalk.gray(`    [${m.researchLine}] ${m.category}/${m.topic}/${m.id} — ${(m.patent.claims ?? []).length} claims`));
+      }
+    }
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('clusters')
+  .description('List patent clusters (grouped solutions)')
+  .action(async () => {
+    const agent = await createQSpherifier({ autonomousMode: false });
+    agent.clusterManager.rebuildClusters();
+    const clusters = [...agent.clusterManager.clusters.values()];
+    if (clusters.length === 0) {
+      console.log(chalk.yellow('No patent clusters yet.'));
+    } else {
+      console.log(chalk.cyan(`Patent clusters (${clusters.length}):`));
+      for (const c of clusters) {
+        const status = c.filingReady ? chalk.green('★ FILING-READY') : chalk.gray('pending');
+        console.log(chalk.white(`\n  ${c.title}`));
+        console.log(chalk.gray(`    ${status} — ${c.memberIds.length} members, lines: ${c.researchLines.join(', ')}`));
+        console.log(chalk.gray(`    Shared concepts: ${c.sharedConcepts.slice(0, 5).join(', ')}`));
+      }
+    }
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('archive')
+  .description('Rebuild archive indices')
+  .action(async () => {
+    const agent = await createQSpherifier({ autonomousMode: false });
+    const r = agent.archivist.rebuildIndices();
+    console.log(chalk.green(`Rebuilt: ${r.total} documents, ${r.patents} patent-eligible.`));
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('status')
+  .description('Print agent status snapshot')
+  .action(async () => {
+    const agent = await createQSpherifier({ autonomousMode: false });
+    console.log(JSON.stringify(agent.status(), null, 2));
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program
+  .command('kg')
+  .description('Print knowledge graph stats and Mermaid diagram')
+  .action(async () => {
+    const agent = await createQSpherifier({ autonomousMode: false });
+    const stats = agent.kg.stats();
+    console.log(chalk.cyan('\nKnowledge Graph Stats:'));
+    console.log(JSON.stringify(stats, null, 2));
+    console.log(chalk.cyan('\nMermaid (first 40 nodes):'));
+    console.log(agent.kg.toMermaid(40));
+    await agent.shutdown();
+    process.exit(0);
+  });
+
+program.parse(process.argv);