# 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, exact vault recall, closure-preserving versor apply, graph diffusion | Zero-cost abstractions, ownership semantics, and Rayon parallelism for the native operations that are parity-gated and explicitly enabled. No hidden backend substitution. |
| **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/specs/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/adr/README.md` table) to see
which domains are *contract-passing* and which are *demonstrated*. As
of 2026-05-23: three domains demonstrated (`mathematics_logic`,
`physics`, `systems_software`); one ratified domain pending its
own promotion ADR (`hebrew_greek_textual_reasoning`).

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

#### Phase 5 — Capability Substrate (ADR-0119 arc)

The §XIII architecture above distinguishes *claim shapes* from *capability*.
ADR-0114 (2026-05-22) opened a separate, explicitly capability-focused arc
toward a first `expert` ledger tier. ADR-0114a defined the 10-point falsifiable
proof framework any `expert` promotion must satisfy. As of 2026-05-23, all 10
obligations are discharged on main for the `gsm8k_math` lane.

**The 10 ADR-0114a obligations and their discharge status:**

| # | Obligation | Discharged by |
|---|---|---|
| 1 | Sealed-holdout discipline | ADR-0119.1 + ADR-0119.7 |
| 2 | OOD surface variation ≥ 0.95 of dev | ADR-0118a |
| 3 | Every correct answer ships replay-equal trace | ADR-0117 |
| 4 | Typed refusal; wrong == 0 | ADR-0116 + ADR-0119.3 + ADR-0119.7 |
| 5 | Reasoning-isolation perturbation suite | ADR-0125 |
| 6 | Compositional-depth curve | ADR-0119.6 |
| 7 | Frontier-baseline comparison | ADR-0119.4 |
| 8 | Adversarial generation; misparse rate zero | ADR-0119.5 |
| 9 | Determinism across release boundaries | solver + verifier + realizer + runner |
| 10 | Operation provenance via pack | ADR-0116 |

**First honest measurement against real GSM8K (ADR-0119.7):**

| Cases | Correct | Wrong | Refused |
|---|---|---|---|
| 1,319 | 0 | 0 | 1,319 |

The parser grammar covers zero GSM8K test problems today. That is the
truthful gap. **The load-bearing differentiator (zero confabulation)
survives the move from CORE-original to real external benchmark.**
CORE refuses what it cannot grammar-handle; it does not confabulate.
ADR-0114a Obligation #4 holds against the external corpus.

This is precisely the inverse of frontier LLM behavior: Claude 3.5
Sonnet reports 96.4% on GSM8K with a nonzero wrong rate; CORE reports
0% correct with 0% wrong. The honest claim is not "CORE matches
frontier LLMs" but "CORE's zero-confabulation property survives the
encounter with an external benchmark." Every future parser expansion
lifts the correct_rate while the wrong_rate gate holds it at zero.

**ADR-0120 (the first `expert` promotion contract) is the next
composable artifact.** It will set the numeric expert threshold
(minimum correct_rate) and ε (depth-curve flatness tolerance),
require all 10 obligations as hard gates, and define the
`expert_claims` schema. The first worked promotion attempt (ADR-0121)
will likely defer honestly on the correct_rate gate — that is the
expected and correct result, consistent with the gate-as-process
pattern established by ADR-0107.

---

### 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-PersonaMotor** — The reasoning persona. A CGA motor (`persona/motor.py`) that biases the field toward a characteristic region of the vocabulary manifold by rotating the field state via a versor sandwich product. The Socratic identity pack (`socratic_v1`) is the canonical example: 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`.*
