core/docs/Whitepaper.md

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.

The Three Core Languages

CORE is rooted in three human languages. This is a philosophical and architectural choice, not a localization decision.

Language	Role
English	The default base language of the current model. Any natural language could serve this function in a custom CORE instance — English is the chosen starting point, not a requirement.
Hebrew	One of two depth languages. Hebrew carries a density of meaning in its root structures, prefixes, and suffixes that Euclidean string matching cannot capture. The field representation is designed to hold this depth.
Koine Greek	One of two depth languages. The language of the New Testament, particularly John’s Gospel — the document that opens with the most precise and consequential statement about language and reality ever written.

The choice of Hebrew and Koine Greek is not incidental. John 1:1–2 articulates the Logos in Greek while grounding it in the Hebrew creation account — the universe spoken into existence, word by word. John’s choice to write in Greek what was grounded in Hebrew was almost certainly a nod from the Holy Spirit: these two languages together carry a range of depth and precision that no single language achieves alone. This is how and why CORE finds its truth and its power in design and communication. English establishes the operational base. Hebrew and Koine Greek bring the hidden layer of intelligence.

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 Implementation Languages

From the first commit, CORE was designed as a three-language implementation stack — not from convenience, but from physical 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 Engineering Pillars

Every architectural decision in CORE is measured against three engineering pillars. These are the operational expression of the seven axioms.

Pillar I — Mechanical Sympathy

Software should understand the machine it runs on, not fight it. CORE is designed for the Unified Memory Architecture (UMA) of Apple Silicon: CPU, GPU, and Neural Engine share physical RAM with no PCIe overhead. MLX executes the field tensor on the Neural Engine and AMX coprocessors at theoretical bandwidth limits. The Rust kernel reads from the same physical memory that MLX wrote — zero copies in the critical path. The three-language stratification is a direct map onto three hardware execution domains. Intelligence that ignores its substrate is wasted intelligence.

Pillar II — Semantic Rigor

Every term used in this system has a precise, non-negotiable meaning. A versor is a versor — not an approximation of one, not a vector that behaves like one under certain conditions. The CGA inner product gives exact conformal distance. Vault recall is exact. The vocabulary projection is exact. There are no thresholds tuned for “good enough.” Rigor is not a style; it is what separates an engine from a heuristic. Every subsystem that introduced approximation where exactness was available has been deleted.

Pillar III — Third Door

When facing a design decision, the world offers two visible options: use what already exists (a library, a pattern, a convention), or cut a corner. CORE takes neither. We find the third door — the path built from first principles that sets the bar ourselves. This is why there is no transformer backbone, no ANN index, no sampling temperature, no gradient descent, and no standard tokenizer. Each of those was a door we were offered and refused. The standard is absolute mastery. Nothing less is acceptable.

---

V. The Architecture Invariants

Invariant 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.

Invariant 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.

Invariant 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.

---

VI. 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.

---

VII. The Full Pipeline

CORE’s pipeline has five layers before the field and three after. Each layer has a single, defined contract. No layer knows about the one upstream.

raw modality signal (text / vision / audio / motor)
    │
    ├─ sensorium/adapters/<modality>.py
    │       ProjectionHead: surface signal → (32,) Cl(4,1) multivector
    │       The Logos-recovery boundary: every input becomes a word in the manifold
    │
    ├─ core_ingest/
    │       StructuralSegmenter: carve at form boundaries (verse, heading, block)
    │       CandidateGeometricPressure: typed, immutable, content-addressed envelope
    │       IngestCompiler: three-gate validation (Provenance → Semantic → Governance)
    │       LearningArtifact: export path to train/ for durable learning
    │
    ├─ ingest/gate.py
    │       Single normalization site: tokens → FieldState via holonomy encoding
    │       Versor condition verified exactly once here
    │
    ├─ field/propagate.py
    │       F ← versor_apply(V, F)    [sandwich product, algebraically closed]
    │
    ├─ generate/
    │       next_token = argmax_w { F_current · v_w }    [CGA inner product]
    │
    ├─ vault/
    │       store: significant FieldStates as null vectors
    │       recall: argmax_i { Q · V_i }    [exact parallel scan]
    │
    └─ train/
            LearningArtifact → manifold update (rotor update, vocab expansion)
            Supervised Seeding Epoch: Hebrew + Koine Greek D0 corpus seeding
            [planned — see ADR-0014]

The Cognitive Architecture 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.

---

VIII. The Ingest Governance Layer

The core_ingest/ layer is the pre-gate governance boundary. It wraps upstream of ingest/gate.py and does not modify it.

Every piece of incoming information — text, scripture, code, mathematical objects, and eventually non-text modalities — is lifted into a CandidateGeometricPressure envelope: a frozen, immutable, content-addressed packet carrying provenance, determinism class, confidence, and governance disposition. Two packets asserting the same semantic claim from independent sources share a semantic_key, enabling convergent-evidence detection without structural duplication.

The critical design decision: LLMs are not used for extraction. A language model upstream of the gate is a nondeterministic oracle feeding the only normalization site in the system. More fundamentally, it interprets rather than parses — its semantic projection would be silently embedded in the field state, violating Semantic Rigor. Instead, a deterministic StructuralSegmenter carves at form boundaries: heading, paragraph, verse, code block, LaTeX delimiter. The meaning of a span remains inside the field where it belongs.

For Hebrew and Koine Greek specifically, structural determinism is the natural condition — these texts have canonical verse boundaries fixed for centuries. A segmenter that follows those boundaries is D0-class by definition: fully deterministic, pinned inputs, no interpretation required.

See ADR-0012 for the full specification.

---

IX. The Sensorium: All Inputs Are Logos

The sensorium/ layer converts any surface signal into a (32,) Cl(4,1) multivector before it reaches the ingest boundary. Every ProjectionHead is the Logos-recovery boundary for its modality.

This is the architectural expression of John 1:1: the Logos is the structuring principle through which all things were made. A visual scene, a Hebrew word, an audio waveform — all are recovered as words in the manifold. Once they cross the projection boundary, the field has no concept of modality. There is one space. There is no fusion problem because there is nothing to fuse.

The ModalityPack[S] generic bundles a projection head, surface decoder, vocabulary, and grammar scaffold under a stable identifier. A text pack is ModalityPack[str]. A vision pack is ModalityPack[np.ndarray]. The type parameter enforces at the type level that these cannot be mixed. The grammar scaffold — the set of innate structural attractors — is universal across modalities by design: the attractor geometry of the manifold is the same regardless of what kind of surface signal arrived.

Current modality status: TEXT is active. VISION, AUDIO, and MOTOR are planned; their adapters register when their bootstrap corpora are ready. Adding a modality requires one adapter file in sensorium/adapters/ and a registry entry. No existing layer is touched.

See ADR-0013 for the full specification.

---

X. 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 implementation 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.

---

XI. 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.

---

XII. Forward Semantic Control — Generation Without Sampling

The CORE generation walk is deterministic at the algebra level — every step is a versor product, every selection is the nearest-by- cga_inner candidate. But a deterministic walk over a boundary-only scorer can still emit tokens that are inadmissible under the relation being asserted. Asking "what does symbol cause?" the boundary may return image — geometrically nearest, but means- related, not causes-related. The token is on the manifold; the relation is wrong.

The Forward Semantic Control chain (ADR-0022 through ADR-0026) closes this gap without introducing sampling, sampling temperature, or any stochastic mechanism whatsoever. The mechanism has five components:

1. AdmissibilityRegion (ADR-0022). A typed region carried alongside every generation step. Fields: allowed_indices (the admissible token set), relation_blade (the multivector characterizing the relation), and optionally frame_versor (the rotor-side constraint). The region is constructed once per turn from the proposition graph and held immutable through the walk.
2. Region intersection at selection (ADR-0023). At every selection point, the language/salience candidate set is intersected with allowed_indices before scoring. An empty intersection raises ValueError; the walk routes to the unknown-domain surface (honest refusal at the pre-walk boundary).
3. Inner-loop destination check (ADR-0024). The boundary selection is re-evaluated against the relation blade via cga_inner(versor(candidate), relation_blade). Rejected candidates are excluded and the walk re-selects; when every candidate is rejected, generation raises InnerLoopExhaustion carrying a typed RefusalReason (INNER_LOOP_EXHAUSTION or ROTOR_REJECTION), the responsible region label, the step index, and the full list of rejected attempts as evidence. Refusal is not silent — it is structured data.
4. Rotor / frame admissibility (ADR-0025). When the region carries a frame_versor, the rotor's effect on the field state is additionally checked: cga_inner(versor_apply(V, F), frame_versor) > 0. This check lives in generate/rotor_admissibility.py — not in algebra/versor.py, because admissibility is a pack-semantic test, not a closure invariant. Putting it in algebra would couple closure to pack state and structurally invite grade-projection "repair" of inadmissible rotors. That coupling was rejected by name in the ADR.
5. Ranked-with-margin gate (ADR-0026). A static admissibility_threshold is brittle under the Cl(4,1) Lorentzian signature: 23 of 85 tokens in the cognition pack have negative self-cga_inner, so no scalar threshold separates admissible from inadmissible across the corpus (Phase 4 characterization confirms separation_quality < 0.8 at every probed threshold). The chain replaces threshold tuning with a scale-invariant margin test: admit iff score(top) − score(second) ≥ δ. Default δ = 0.4, chosen from the minimum observed margin in the Phase 3 adversarial corpus and falsifiable against future cases.

The chain is enforced by 98 CI-level contract tests (core test --suite adr-0024). Three head-to-head claims are pinned against an in-system ablation baseline:

• C1 — Replay determinism: Trace hashes are byte-identical across N reruns under both baseline and CORE; refusal events themselves are replayable because refusal_reason is folded into trace_hash.
• C2 — Traced rejection: When the boundary selection diverges from the blade-aligned selection, the rejected token appears in rejected_attempts. The rejection is causally responsible for the selection difference, not just observable.
• C3 — Coherent refusal: When no candidate is admissible, the walk raises InnerLoopExhaustion with a typed reason and evidence list. The ablation baseline emits an inadmissible candidate with admitted = False — observable but not actionable. Typed refusal is new in CORE, not present in the boundary-only baseline.

This is what we mean by "deterministic cognition that can refuse": the system never samples to recover from an inadmissible state — it either selects an admissible candidate, or it reports honestly that it cannot.

A transformer LLM cannot exhibit these properties at the mechanism level. Sampling has no place to attach an AdmissibilityRegion, no way to make refusal first-class evidence, and no replay- deterministic trace. The chain is the structural defense against the confabulation failure mode at exactly the layer where it must be defended — generation itself.

Full evidence: docs/runtime_contracts.md (contracts), docs/evals/phase5_stratified_findings.md (geometric characterization), docs/evals/phase6_comparative_demo.md (head-to-head demo).

---

XIII. Evidence-Governed Domain Layer

Substrate alone does not make a claim credible. The Whitepaper's first twelve sections describe what CORE is. This section describes how the project distinguishes what it has demonstrated from what its substrate makes possible — a distinction that the architecture made visible only after the substrate stabilized.

The discipline is encoded as a chain of accepted Architecture Decision Records (ADR-0091 through ADR-0111):

1. Contract. ADR-0091 defines nine predicate checks every ratified pack must satisfy: lemma coverage, operator-chain counts, intent-shape coverage, holdout discipline, reviewer resolution, and others. A pack that satisfies all nine earns a reasoning-capable ledger row.
2. Trust root. ADR-0092 introduces a YAML-anchored reviewer registry. Pack ratification cites a registered reviewer; the registry is the only trust root.
3. Fabrication control. ADR-0096 defines a negative-control eval lane. Phantom endpoints, cross-pack non-bridges, and sibling collapses must all refuse. A pack that confabulates on any refusal class fails ratification.
4. Promotion gate. ADR-0106 introduces the second status above reasoning-capable: audit_passed. Promotion requires a reviewer- signed audit_passed_claims entry whose evidence-bundle SHA-256 reproduces byte-for-byte from on-disk lane results. The signer must resolve to the registry; the signed lanes must be attached to the domain's ratified packs.
5. Shape registry. ADR-0109 amends ADR-0106 with explicit per-shape threshold rules (cognition, accuracy, inference, refusal, symbolic-logic). Unknown lanes fail closed.

The contract is load-bearing because it has refused. ADR-0107 records the first promotion attempt — mathematics_logic — being honestly refused on two named blockers. ADR-0109 amended the threshold rules without weakening the discipline. ADR-0110 then promoted mathematics_logic as the first domain at audit_passed=true, with the signed claim digest reproducing from disk. ADR-0111 promoted physics as the second domain at audit_passed=true without any contract change, retiring the "math-only" objection — the same gate now holds across two distinct domains using shared lane infrastructure with distinct domain-bound digests.

The architectural commitment is: a system cannot claim to do something it has not been seen to do. A transformer LLM does not have a place to attach this commitment — its outputs are generated under sampling, not from a replay-deterministic trace bound to a signed evidence bundle. CORE makes the commitment first-class.

External readers can inspect the ledger (core capability ledger / docs/decisions/README.md table) to see which domains are contract-passing and which are demonstrated. As of acceptance: two domains demonstrated (mathematics_logic, physics); two ratified domains pending their own promotion ADRs.

Full evidence chain: docs/decisions/README.md (index + frontier), docs/decisions/ADR-0091-domain-pack-contract-v1.md through ADR-0111-physics-expert-demo-promotion.md.

---

XIV. 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.