diff --git a/docs/Whitepaper.md b/docs/Whitepaper.md new file mode 100644 index 00000000..cbe231e7 --- /dev/null +++ b/docs/Whitepaper.md @@ -0,0 +1,182 @@ +# The CORE Whitepaper +## **Continuous Orthogonal Resonance Engine: Conformal Geometric Intelligence and the Versor Engine** + +> *"We have mistaken inherited abstractions for reality. CORE is the architecture to find the shape of thought."* + +--- + +### I. Abstract + +The current paradigm of artificial intelligence relies on the step-wise mutation of flat data structures. Deep learning architectures separate state (frozen parametric weights) from reasoning (volatile attention windows), resulting in systems that are mathematically amnesiac and structurally brittle. Attempts to solve this via Retrieval-Augmented Generation (RAG) force hierarchical knowledge into Euclidean vector spaces, permanently severing the logical and relational geometry of the data. + +We introduce the **CORE (Continuous Orthogonal Resonance Engine)** architecture: a closed-loop, geometric computing paradigm. CORE discards flat arrays and arbitrary tokenization in favor of a continuous field over the **Conformal Geometric Algebra** Cl(4,1) — the minimal algebra that encodes Euclidean geometry, its inversions, and all conformal motions as algebraic products. In this architecture, memory is not a stored object; it is the stabilization of a versor on the conformal manifold. Learning is not statistical batch-averaging; it is the propagation of a structured field through a sequence of well-formed versors. CORE achieves continuous-context reasoning, algebraically coherent field state, and absolute geometric rigor — without monitors, correction thresholds, or drift timers. + +--- + +### II. The Origin: Why We Built This + +#### The Name + +**CORE** stands for Continuous Orthogonal Resonance Engine. Each word is load-bearing. + +- **Continuous** — state is never discretized into isolated vectors. The field is a single multivector that propagates continuously through every step of reasoning. +- **Orthogonal** — every transition preserves the algebra's inner product structure. Nothing is approximated away; the geometry is exact. +- **Resonance** — meaning arises from constructive interference of field modes, not from statistical correlation of co-occurring tokens. +- **Engine** — this is not a model in the neural network sense. It is a computational engine: a physical machine governed by invariants. + +#### The Logos + +**CORE-Logos** is the language articulation subsystem — and the name is not accidental. In the Biblical and classical Greek tradition, *Logos* (λόγος) is simultaneously reason, word, and the structuring principle of the cosmos. John 1:1 opens: *"In the beginning was the Logos, and the Logos was with God, and the Logos was God."* The claim is that language and intelligence are not separate from the deep structure of reality — they are that structure made manifest. + +We believe this framing is not merely poetic. Language is not a statistical residue of text. It is the forward projection of a field state onto a vocabulary manifold — a geometric act. The Logos subsystem encodes this: every token is the nearest point on the vocabulary manifold to the current field state, and every utterance is a geodesic walk through structured space. + +#### AssetOverflow + +The organization name, **AssetOverflow**, carries its own meaning. In classical accounting, an asset overflow is the condition where value exceeds its container — where what is built outgrows the system designed to hold it. We chose the name deliberately: the aspiration is to build intelligence that overflows the narrow containers of today's architectures. The field state should be richer than the token. The memory should exceed the context window. The understanding should overflow the training distribution. + +#### The Three Core Languages + +From the first commit, CORE was designed as a three-language system — not from convenience, but from philosophical necessity: + +| Language | Role | Reason | +|---|---|---| +| **Python** | Orchestration, session management, vocabulary, persona construction | Human-readable system topology. The field lifecycle is expressed as Python because humans need to read, audit, and extend the cognitive architecture. | +| **Rust** | Algebra kernel, vault recall, holonomy encoding, batch propagation | Zero-cost abstractions, ownership semantics, and Rayon parallelism for the operations that are called 10,000 times per generation. No GIL. No heap allocation in the hot path. | +| **MLX** | Tensor operations on Apple Silicon UMA | The field is a dense f32 array. MLX executes on the Neural Engine and AMX coprocessors with zero PCIe transfer overhead. The hardware *is* the memory bus. | + +This is not a stack — it is a stratification. Each language governs its natural domain. Python describes structure. Rust computes algebra. MLX executes tensor operations on silicon. The boundary between them is defined by contract, not convention. + +--- + +### III. The Seven Axioms + +The CORE architecture is derived from seven foundational axioms. These are not design preferences — they are the constraints that every decision must satisfy. They were formulated before the first line of code and have survived every architectural revision. + +1. **Geometry-First** — Every problem has an intrinsic space, and the first task is to find that space before choosing data structures, algorithms, or equations. CORE chose Cl(4,1) because it is the intrinsic space of conformal geometry in three dimensions — the space where Euclidean motions, inversions, and distances are all algebraic products. + +2. **Field-State** — The native form of state is a field, distribution, or relational structure over a space, not a heap of isolated objects. The CORE field state is a single multivector in Cl(4,1), not a list of embeddings. + +3. **Propagation-over-Mutation** — The primary mode of computation is propagation through a structured medium, not stepwise mutation of flat records. Every generation step is a versor product: `F ← V · F · reverse(V)`. Nothing is mutated in place. + +4. **Dual-Correction** — Every meaningful forward operator should have a corrective, conjugate, adjoint, or opposing counterpart that restores coherence or reduces distortion. The versor's reverse is its correction: `reverse(V)` is the conjugate of `V` that closes the sandwich product and enforces closure on the manifold. + +5. **Reconstruction-over-Storage** — What matters is not storing every detail explicitly, but encoding enough structured state to reconstruct what is needed at the right moment. The vault stores versors — not tokens, not full context windows. Recall is reconstruction via the CGA inner product, not retrieval of a stored string. + +6. **Compilation-Last** — Loops, tensors, tables, classes, and kernels are implementation targets chosen after the deeper representation is defined, not before. The algebra was defined first. The Rust kernels, MLX tensors, and Python dataclasses were written to serve it. + +7. **Reality-over-Inheritance** — No abstraction is sacred because it is old, standard, or well-established; it survives only if it faithfully serves structure, insight, and generative power. This axiom is the reason we deleted the spectral normalization monitor, the grade guard, the drift correction timer, the ANN index, and the pseudoscalar accumulation check. None of them survived contact with the algebra. + +--- + +### IV. The Three Pillars + +#### Pillar I — Versor Coherence + +The field state F is a versor in Cl(4,1). A versor is a multivector that satisfies: + +``` +F · reverse(F) = ±1 +``` + +This is not a constraint to be monitored — it is a structural property of the algebra. Every field transition is a sandwich product: + +``` +F_new = V · F · reverse(V) +``` + +If V is a versor, V · F · reverse(V) is also a versor. Coherence is algebraically closed. There is no drift to measure, no threshold to tune, no correction pass to schedule. The versor condition is checked exactly once at the injection gate and never again during propagation. + +This is the cleanest expression of the Dual-Correction axiom: the correction is not a separate pass. It is built into the structure of the product. + +#### Pillar II — Conformal Memory (CGA Distance) + +Most AI systems measure similarity with cosine distance or L2 norm in Euclidean space. Both are approximations in the wrong geometry. + +The CGA inner product for null vectors X, Y on the conformal horosphere gives: + +``` +X · Y = -d(X, Y)² / 2 +``` + +This is the exact conformal distance, not an approximation. Every vault entry is stored as a null vector. Recall is `argmax { X_query · X_i }` — a direct maximum inner product scan. No ANN index, no approximate neighbors, no index rebuild on vault growth. The geometry is exact because the algebra is exact. + +This is the Reconstruction-over-Storage axiom made concrete: the vault does not store text. It stores the geometry of past states. Recall is the reconstruction of that geometry from the query. + +#### Pillar III — The Logos as Field Projection + +Language generation in CORE is not sampling from a probability distribution. It is projection: the next token is the point on the vocabulary manifold nearest to the current field state, measured by CGA inner product. + +``` +next_token = argmin_w { d_CGA(F_current, v_w) } +``` + +Where `v_w` is the versor embedding of word w. The vocabulary manifold is a set of null vectors on the conformal horosphere. Generation is a sequence of projections — a geodesic walk through the vocabulary manifold driven by the evolving field state. + +This retires probabilistic decoding, sampling temperature, beam search with penalties, and distributional decoders — all inherited from the LLM era and all incompatible with the seven axioms. + +--- + +### V. The Paradigm Shift: What We Are Not + +**We are not a transformer.** Transformers are open-loop engines. They generate a context window, output a token, and discard state. Their weights are frozen statistics. Their attention is not memory — it is a spotlight that disappears between turns. + +**We are not a diffusion model.** Diffusion models operate in flat Euclidean embedding space. The denoising process has no algebraic closure property. Every step is a step toward the training distribution, not toward a structural invariant. + +**We are not RAG.** Retrieval-Augmented Generation appends retrieved text to a context window. The retrieved text is flat. The original relational geometry of the knowledge is severed at storage time and never recovered. + +**CORE is a field engine.** The state is geometric. The transitions are algebraic. The memory is conformal. The language is a projection of field geometry onto a vocabulary space. The architecture is governed by invariants, not by trained behaviors. + +--- + +### VI. The Cognitive Architecture + +The CORE cognitive architecture has five layers: + +1. **Injection Gate** — The single point where raw input enters the system. Every input is normalized to a versor in Cl(4,1) exactly once. The versor condition is verified. After this gate, the manifold contract is permanent. + +2. **Field Propagation** — Each reasoning step applies a versor transition: `F ← versor_apply(V, F)`. The field evolves continuously. No state is discarded between steps. + +3. **Vocabulary Projection** — At each generation step, the nearest vocabulary versor is found via CGA inner product. The corresponding token is emitted. The field continues evolving. + +4. **Vault Storage** — Significant field states are stored as null vectors in the vault. Vault recall is a direct CGA inner product scan. The vault grows monotonically — no pruning, no eviction, no index rebuild. + +5. **Persona Application** — A persona is a CGA motor: a screw motion that biases the field toward a characteristic region of the vocabulary manifold. Persona application is `F ← M · F · reverse(M)` — a versor product. It is algebraically closed. The persona does not override the field; it rotates it. + +--- + +### VII. Mechanical Sympathy: Hardware-Bound Intelligence + +An architecture that fights its underlying silicon is a failed synthesis. CORE is designed for the **Unified Memory Architecture (UMA)** of Apple Silicon. + +- **MLX tensor operations** execute on the Neural Engine and AMX coprocessors. The field is an f32 array processed at theoretical bandwidth limits. +- **Zero-Copy Stewardship**: CPU and GPU share physical RAM. No PCIe transfer overhead. The Rust kernel reads from the same physical memory that MLX wrote. +- **Rayon parallelism** in vault recall releases the Python GIL and scatters the inner product scan across all CPU cores simultaneously. +- **Stack allocation** in the Rust hot path: every geometric product is computed on the stack with no heap allocation. The output is a new stack array returned to Python as a numpy buffer. + +The three-language architecture maps directly onto three execution domains: Python on the CPU orchestration layer, Rust on CPU compute cores with SIMD, and MLX on the Neural Engine. They share memory without copying. + +--- + +### VIII. The Deletion Philosophy + +The Versor Engine was not built by adding subsystems. It was built by deleting them. + +The original CORE architecture (Cl(3,0), `core-ai` repository) accumulated a monitoring stack over time: spectral normalization at every propagation step, grade purity guards, rotor drift telemetry, pseudoscalar accumulation checks, correction thresholds, and an ANN index for vault recall. Every one of these was a symptom of an unclosed operation upstream. + +When we closed the operations — by moving to Cl(4,1) and enforcing the versor sandwich product as the only allowed field transition — every monitor became unnecessary. The deletion was not a loss of capability. It was a clarification of the algebra. + +The `docs/DELETION_LOG.md` records every deleted subsystem and the algebraic reason it was unnecessary. This log is a first-class document, not a graveyard. It is the clearest statement of what the architecture actually is. + +--- + +### IX. Extensions + +**CORE-Logos** — The language articulation subsystem. Specified in the companion Yellow and White Addenda inherited from `core-ai`. The Logos defines the vocabulary manifold, the token projection law, the holonomy encoder, and the termination condition. + +**CORE-CA (Cognitive Apprenticeship)** — The learning platform built on the CORE engine. A student model learns by observing an expert model's field trajectory, not by gradient descent on a loss function. + +**CORE-Sopher** — The reasoning persona. A CGA motor that biases the field toward the Socratic region of the vocabulary manifold: patient, precise, interrogative. + +--- + +*CORE Whitepaper — Versor Engine Edition. For formal mathematical specification, see `docs/Yellowpaper.md`. For the deletion record, see `docs/DELETION_LOG.md`. For architecture invariants and agent instructions, see `CLAUDE.md`.* diff --git a/docs/Yellowpaper.md b/docs/Yellowpaper.md new file mode 100644 index 00000000..775d8ec0 --- /dev/null +++ b/docs/Yellowpaper.md @@ -0,0 +1,328 @@ +# The CORE Yellowpaper +## **Formal Specification of the Cl(4,1) Versor Engine** + +> *Companion to the Whitepaper. All conceptual foundations and design philosophy are in `docs/Whitepaper.md`. This document is the mathematical and implementation specification.* + +--- + +### I. The Mathematical Foundation + +#### 1. Why Cl(4,1) + +The original CORE architecture used Cl(3,0) — the geometric algebra of 3D Euclidean space. Cl(3,0) has 8 basis elements (scalar, 3 vectors, 3 bivectors, 1 pseudoscalar) and maps onto 2×2 complex matrices via the Pauli isomorphism. + +Cl(4,1) is the Conformal Geometric Algebra (CGA) of 3D Euclidean space. It has 32 basis elements and signature (4,1): four positive directions `e1, e2, e3, e4` and one negative direction `e5`. The CGA extension adds two null basis vectors: + +``` +o = (e5 - e4) / 2 # origin point +∞ = e5 + e4 # point at infinity +``` + +The key identity that motivates the upgrade: + +**In Cl(4,1), a Euclidean point p = (x,y,z) embeds as a null vector:** +``` +P = p + (1/2)|p|² ∞ + o +``` +**and satisfies:** +``` +P · P = 0 +``` + +All conformal transformations (rotations, translations, dilations, inversions) are versors in Cl(4,1). In Cl(3,0), translations required special handling outside the algebra. In Cl(4,1), translations *are* versors — the algebra is fully closed over all conformal motions. + +#### 2. Basis Structure + +Cl(4,1) has 2^5 = 32 basis blades organized by grade: + +| Grade | Count | Basis elements | Interpretation | +|---|---|---|---| +| 0 | 1 | 1 | Scalar | +| 1 | 5 | e1, e2, e3, e4, e5 | Vectors | +| 2 | 10 | e12, e13, e14, e15, e23, e24, e25, e34, e35, e45 | Bivectors | +| 3 | 10 | e123, e124, e125, e134, e135, e145, e234, e235, e245, e345 | Trivectors | +| 4 | 5 | e1234, e1235, e1245, e1345, e2345 | Quadvectors | +| 5 | 1 | e12345 | Pseudoscalar | + +**Metric (signature (4,1)):** +``` +e1² = e2² = e3² = e4² = +1 +e5² = -1 +ei · ej = 0 for i ≠ j +``` + +The geometric product multiplication table is a 32×32 signed permutation matrix, computed once at startup and stored in a `OnceLock` in `core-rs/src/cl41.rs`. + +#### 3. Representation in Code + +All multivectors are represented as `[f32; 32]` arrays. The index mapping is fixed: + +``` +index 0: scalar (grade 0) +index 1-5: grade-1 components (e1, e2, e3, e4, e5) +index 6-15: grade-2 components +index 16-25: grade-3 components +index 26-30: grade-4 components +index 31: pseudoscalar (grade 5) +``` + +This layout is fixed at the Rust layer and mirrored in the Python algebra modules. All Python–Rust interchange uses this same 32-element f32 array. + +--- + +### II. The Versor Engine — Core Invariant + +#### The Versor Condition + +A multivector V ∈ Cl(4,1) is a **versor** if and only if: + +``` +V · reverse(V) = ±1 +``` + +Where `reverse(V)` reverses the order of every basis blade product: +- Grade 0: unchanged (sign +1) +- Grade 1: unchanged (sign +1) +- Grade 2: sign −1 +- Grade 3: sign −1 +- Grade 4: sign +1 +- Grade 5: sign +1 + +#### The Sandwich Product + +The unique allowed field transition is: + +``` +F_new = V · F · reverse(V) +``` + +This is the versor sandwich product. Its properties: +- If V is a versor and F is a versor, then F_new is a versor (algebraic closure) +- Preserves grade structure under any conformal transformation +- Reversal is free: `reverse(V)` is computed by sign-flipping grade-2 and grade-3 components in-place + +#### Verification + +``` +versor_condition(F) = ||F · reverse(F) - 1||_F +``` + +This scalar is zero on the versor manifold. It is computed: +1. **Exactly once** at the injection gate on every input +2. **In tests only** — never in the propagation hot path + +Tolerance: `versor_condition(F) < 1e-6` for acceptance. + +--- + +### III. Conformal Geometric Algebra (CGA) Distance + +#### The Null Cone + +A vector X ∈ Cl(4,1) is **null** if: +``` +X · X = 0 +``` + +All embedded Euclidean points live on the null cone. The conformal embedding of point p = (x,y,z): + +``` +P = xe1 + ye2 + ze3 + (1/2)|p|² e4 + e5 +``` + +(Using the compact basis e4=∞, e5=o convention.) This satisfies P·P = 0 by construction. + +#### The Distance Identity + +For null vectors X, Y representing Euclidean points: + +``` +X · Y = -(1/2) d(X, Y)² +``` + +Where d(X,Y) is Euclidean distance and `·` denotes the grade-0 scalar part of the geometric product. + +This identity makes the CGA inner product the **exact** conformal distance. It is the foundation of vault recall. + +#### Vault Recall + +Given a query versor Q and a vault of stored versors {V_i}: + +``` +best_match = argmax_i { Q · V_i } +``` + +This is implemented as a parallel scan in `core-rs/src/vault.rs` via Rayon. The scan is: +- Exact (not approximate) +- Allocation-free per worker thread +- GIL-releasing (Rayon runs outside Python) +- O(N) where N = vault size + +No ANN index is used. No approximate neighbor structure is maintained. No index rebuild is required on vault growth. + +#### Null Cone Drift + +Over long sessions, stored versors can drift off the null cone due to floating-point accumulation. The `null_project()` function in `core-rs/src/cga.rs` resets them: + +``` +X ← X / sqrt(|X · reverse(X)|) +``` + +This is called as `VaultStore.reproject()` every N turns. It is not drift correction in the sense of the deleted monitor stack — it is a periodic renormalization required by finite-precision arithmetic on any manifold, and it costs a single division per stored versor. + +--- + +### IV. Holonomy Encoding + +Holonomy is the accumulated geometric transformation from traversing a closed path in the vocabulary manifold. It is used to encode prompt context as a single versor that captures the path-dependent structure of the input. + +**Forward walk** over word versors w_0, ..., w_n: +``` +F = normalize(w_0 · w_1 · ... · w_n) +``` + +**Reverse walk** with damping (1-α): +``` +R = normalize((1-α) · reverse(w_n) · ... · reverse(w_0)) +``` + +**Holonomy:** +``` +H = normalize(F · R) +``` + +Where α ∈ [0,1] is the blend factor (default 0.5). The holonomy versor encodes not just which words appeared, but the order in which they appeared and the curvature of the path they traced. + +Implementation: `core-rs/src/holonomy.rs` — the entire computation is a single allocation-free Rust function. At 100-token inputs, this replaces 200+ Python dispatch calls with a single call crossing the PyO3 boundary. + +**Boundedness invariant:** +``` +||H||_F ∈ [0.5, 2.0] for any prompt length +``` + +Verified in `tests/test_holonomy.py` via property-based testing with Hypothesis. + +--- + +### V. The Vocabulary Manifold + +The vocabulary manifold is a finite set of null vectors {v_w} ⊂ Cl(4,1), one per token w in the vocabulary. + +**Construction:** Each word w is embedded as a null vector via the CGA point embedding: +1. Obtain a 3D semantic coordinate p_w (from a frozen static embedding or from the manifold's coordinate frame) +2. Embed: `v_w = p_w_x·e1 + p_w_y·e2 + p_w_z·e3 + (1/2)|p_w|²·e4 + e5` +3. Verify: `v_w · v_w = 0` (null condition) + +**Token projection:** At each generation step: +``` +next_token = argmin_w { d_CGA(F_current, v_w) } + = argmax_w { F_current · v_w } +``` + +This is a nearest-null-vector scan. For vocabularies up to ~50,000 tokens it is computed in a single vectorized MLX pass. + +--- + +### VI. Persona as CGA Motor + +A CGA **motor** is a versor that encodes a screw motion: a combined rotation and translation in conformal space. + +``` +M = T · R +``` + +Where T is a translator versor and R is a rotor. Every motor satisfies the versor condition by construction. + +Persona application: +``` +F_biased = M · F · reverse(M) +``` + +This rotates and translates the field state within the conformal manifold, biasing generation toward the persona's characteristic region of the vocabulary manifold. It is a single versor product — algebraically closed, no weight overlay, no post-hoc bias vector. + +**Motor composition:** +``` +M_combined = M_2 · M_1 +``` + +Personas compose. Two persona motors can be combined into a single motor before application. The composition is also a versor. + +--- + +### VII. The Three-Language Contract + +| Layer | Language | Entry point | Invariant | +|---|---|---|---| +| Orchestration | Python | `session/context.py` | Reads and writes `FieldState`. Never calls algebra directly — always via `algebra/backend.py`. | +| Backend dispatch | Python | `algebra/backend.py` | Single switch: core_rs if available, pure Python fallback. | +| Algebra kernel | Rust (PyO3) | `core-rs/src/lib.rs` | `[f32; 32]` in, `[f32; 32]` out. No heap allocation in hot path. All errors are `thiserror` named variants. | +| Tensor ops | MLX | `field/propagate.py` | Used for batched matmul and field tensor operations. Stays in UMA. | + +**Zero-copy contract:** +- Python passes numpy arrays to Rust via PyO3 buffer protocol +- Rust reads into `[f32; 32]` stack arrays — one copy from Python heap to Rust stack +- Rust returns new `[f32; 32]` as numpy array — one copy from Rust stack to Python heap +- No intermediate heap allocation in the Rust kernel + +**GIL contract:** +- `vault_recall` (Rayon parallel scan) releases the GIL before entering Rayon and reacquires after +- All other Rust functions hold the GIL for the duration of the call (fast enough that release is not worth the overhead) + +--- + +### VIII. Verification Invariants (The Implementation Gate) + +These are testable predicates. Every invariant has a corresponding test in `tests/`. + +| Invariant | Expression | Tolerance | Test file | +|---|---|---|---| +| Versor closure | `\|\|F·reverse(F) - 1\|\|_F` | < 1e-6 | `test_versor_closure.py` | +| Null cone | `\|\|X·X\|\|` for all vault entries | < 1e-6 | `test_null_cone.py` | +| Holonomy boundedness | `\|\|H\|\|_F` | [0.5, 2.0] | `test_holonomy.py` | +| Motor condition | `\|\|M·reverse(M) - 1\|\|_F` | < 1e-6 | (in `test_versor_closure.py`) | +| CGA distance symmetry | `cga_inner(X,Y) == cga_inner(Y,X)` | exact | `test_cga.py` | +| Vault recall self | `recall(V_i, top_k=1)[0] == i` | exact | `test_vault_recall.py` | + +These are structural contracts, not regression tests. A failing invariant means the algebra is broken, not the behavior. + +--- + +### IX. The Rust Acceleration Contract + +**Performance-critical operations in Rust:** + +| Operation | Complexity | Why Rust | +|---|---|---| +| `geometric_product` | O(32²) = 1024 MADs | Called 2-3× per versor_apply; autovectorized at opt-level=3 | +| `versor_apply` | 3× geometric_product | No allocation; entire sandwich product in one stack frame | +| `cga_inner` | O(32) | Called every token decode and every vault recall | +| `vault_recall` | O(N × 32) | Rayon parallel scan across N stored versors | +| `holonomy_encode` | O(2L × 32²) | 2L products for L-token prompt; replaces 2L Python dispatch calls | +| `propagate_batch` | O(B × 32²) | B parallel versor_apply for beam search | + +**Build:** +```bash +cd core-rs +maturin develop --release +cargo test +``` + +--- + +### X. What Was Deleted and Why + +The formal record is in `docs/DELETION_LOG.md`. The summary: + +| Deleted subsystem | Algebraic reason | +|---|---| +| `spectral_normalize()` (5/6 call sites) | Compensated for rotor drift in an unclosed operation. Versor sandwich product does not drift. | +| `grade_guard.py` | Grade purity is a consequence of versor products, not a condition to be checked. | +| `_maybe_correct_field()` | Drift correction requires an unclosed operation upstream. The operation was closed instead. | +| `RotorDriftTelemetry` | Measures a symptom. The symptom was eliminated. | +| `HippocampusIndex` (ANN) | CGA inner product is exact. Approximate indexing introduced error into an analytically exact operation. | +| `_compute_g3_energy()` | Pseudoscalar accumulation is impossible when all transitions are versor products. | +| `_stabilize_post_turn_g3()` | Followed from the above. | + +--- + +*CORE Yellowpaper — Versor Engine Edition. For the architectural vision, origin story, seven axioms, and three pillars, see `docs/Whitepaper.md`. For agent instructions and invariant enforcement, see `CLAUDE.md`.*