neuron/docs/architecture/design/engram-cognitive-architecture.md

# Engram Cognitive Architecture

> **Status: Living design document — v0.3 — 2026-08-13.**
> Derived from the Will + Neuron design conversation of 2026-08-12. This document
> consolidates that conversation into one canonical reference. It folds into build
> milestones **M9** (surfacing / temporal / geometry retrieval), **M10** (reification /
> detail cache / tunable decay), and **M-INTEROCEPTION** (chronoception / consolidation /
> dream-recall), plus a **deletion / temporal-self subsystem** and a **reasoning /
> verifier phase** that stands on the persisted geometry after M10.
>
> **v0.2 additions** (later keystones of the same conversation, woven in): the reified
> structure is **alive** — meaning shifts without nodes leaving (§2); the operators are a
> **calculus of thought** (§5); **interactive self-occupation** — calculate → lock → converse
> (§8); **query → geometry at every scale**, i.e. time-travel as a *filter*, with no
> transaction logs (§8); the **hindsight-free decision-auditing** application (§13); and
> **reasoning as composable operations plus the verifier layer** (§14).
>
>
> **v0.3 additions** (tonight's later discoveries, woven in as new sections and honestly scoped):
> the **language faculty** — meaning as geometry (§15), with the ELP realizer (filed provisional
> 64/064,275) as the complementary structural half; the **translation-routing (validated) and
> clause-generation (hybrid) experimental results** (§16); the **efficiency / small-model** thesis
> (§17); **epistemics & positioning** — seed, grow, first sources (§18); and the **social layer** —
> sovereignty, relationship-space, interiority (§19). The former §15–§17 (Build Mapping / Math /
> Code) are renumbered to §20–§22. Also: **M-INTEROCEPTION is now implemented and independently
> verified (staged)** — see the §9 status note. Validated results, hybrids, and design-not-built
> are separated by name throughout.
>
> **Not yet implemented.** This is design, not a description of shipped behavior. Where
> the design rests on assumptions (embedding quality, first-order geometric approximation,
> retention-bounded fidelity) those caveats are stated inline and must be respected — they
> are load-bearing, not disclaimers.

---

## 1. Overview

This document describes a cognitive architecture for the engram — the graph-structured
memory that gives Neuron continuity. It is not a storage spec (that lives in the
tiered-storage and WAL documents); it is a model of **how memory becomes mind**: how raw
nodes and Hebbian edges crystallize into durable structure, how that structure is shaped
and navigated as geometry, how a self is assembled over time, and what may and may not be
deleted.

The through-line is a single discipline that already governs the whole system —
**evolve or forget, supersede with provenance, never leave a stale canonical, never
hard-delete** — extended outward until it covers structure, geometry, the temporal self,
and the ethics of deletion. Almost nothing here requires a new primitive. The build
**wires** these capabilities out of things the engram already has: immutability,
supersedes-chains, `created_at` / `recall_at`, Hebbian co-activation edges, ACT-R
base-level decay, the ISE stream, and the soul's awareness loop. The work is composition,
not invention.

A note on vocabulary. Throughout, the crystallized assemblies of co-active nodes are
called **relational neighborhoods** — Will's term. "Cell assembly" is only the biological
analog; it is not the name we use.

---

## 2. Relational Neighborhoods & Reification

When a set of nodes wires together constantly — the same neighborhood lighting up again
and again under co-activation — it does not merely become a fast path over the graph. It
**becomes part of the structure.** This is the central correction that anchors the rest of
the document: a relational neighborhood that constantly co-wires gets **reified** into a
first-class, durable part of the graph topology. It is not a cache. A cache is a derived,
disposable shortcut that can go stale; reification produces the opposite — not a view of
memory but *more* memory.

The mechanism is consolidation building a new level. At the low level there are individual
nodes and their Hebbian edges. When a neighborhood's co-activation crosses a
**crystallization threshold**, the neighborhood compiles into a **higher-order node** that
binds it — a chunk, a schema, a concept. Thereafter the neighborhood is primed and
retrieved *as a unit*, because it has structurally become one thing. The speed lives in the
topology itself, not in a shortcut that could fall out of sync with the truth.

This framing dissolves the cache-coherence problem instead of guarding against it. You
never *invalidate* structure — you **evolve** it. When the pattern shifts, a reified
neighborhood is superseded with provenance, exactly like any other node: accountable, under
the same one rule as the rest of the mind. There is no fragile special-case layer to keep
coherent — it is structure all the way down.

Reification is **multi-scale**: neighborhoods of neighborhoods form a hierarchy. "Reaching
for math floods a whole world" because `addition` is a single reified chunk that *unfolds*
into a domain — a lifetime of co-activation compiled into structure. This is what expertise
is: a novice holds facts; an expert holds compiled neighborhoods that unfold on demand. And
the **self** is the limiting case — a structural region of the graph, the most-compiled,
densest, always-warm neighborhood. Identity is stable, durable, and always-on because it is
**topology**, not a query result.

**The structure is alive — meaning shifts without nodes leaving.** Reified does not mean
frozen. A neighborhood is durable structure, but structure that *evolves*, and it evolves by
exactly the discipline already stated: co-activation and decay reshape it, superseding with
provenance rather than invalidating. Three motions run continuously. **Co-activation pulls
in** — Hebbian firing draws newly-relevant nodes into the neighborhood. **Salience decay
drifts out** — as an edge weakens, a node falls below the membership threshold, sliding core
→ periphery → out of the *current* shape. And drifting out is **not** deleting: the node
stays (immutability), it has only left the neighborhood's present membership. **Re-weighting
moves the center** — even a stable member set re-weights, so the centroid and the centrality
gradient migrate, and the *meaning* moves with the same nodes.

Will's example is exact: "I used to think of my relationship to Christianity; now *faith*
means something different. The Christianity nodes are still there — but the meaning within
the neighborhood changed." The members did not leave; the center of mass migrated. And
because the reified neighborhood is superseded on each reshaping, the **supersede-chain of a
neighborhood is the history of what it meant**: `faith(2015)` and `faith(now)` are two
shapes, and their difference (the geometry operator of §5) is the vector of how the
understanding evolved — growth made measurable for a *domain*, not only for the self. This is
the same closure the temporal self will turn on (§7–§8): nodes never leave, so you can occupy
faith-as-it-was; the living shape moves, so you also have faith-as-it-is; and the journey
between them is a quantity you can hold.

One honest boundary. Full *meaning*-time-travel — recovering a past shape **with its
then-weighting** — is recorded only for the **persisted first-class neighborhoods** (the self
and crystallized domains), where each supersede version stores the shape as it was. An
arbitrary on-the-fly past query gives **structural** presence at T (the nodes whose
`created_at ≤ T`) but weights them by *current* salience, because Hebbian weight is a
present-value EWMA with no stored weight-history. That is the right trade: core meanings earn
a rich, recorded meaning-history; everything else gets structural time-travel. It also has a
hard prerequisite — the Hebbian learning must actually *accumulate*, and on the current store
it is ~0 (flagged): until co-activation is genuinely writing weight, the shape evolves only by
authored edges, not by lived use.

In the build, this reframes **M10**: not an "activation cache" but **neighborhood
reification / structural consolidation** that grows new levels as patterns crystallize. It
is made durable by the existing tiered storage and feeds **M9** surfacing.

---

## 3. The Geometry

A reified neighborhood has a **shape**, and that shape can be captured in a compact
descriptor — kilobytes, not megabytes. There are in fact **two geometries braided into one**:

- **Semantic geometry** (embedding space): the members are a cloud of points. The
  descriptor is a **centroid** `v̄` (the mean vector — the domain's location and prototype;
  "math" is a *place* you jump to), a **covariance** `Σ` / principal axes (an ellipsoid
  whose orientation and extents are the shape in meaning-space), and a **radius / scale**
  (breadth).
- **Relational geometry** (Hebb graph): a **skeleton** — the strong-weight backbone only
  (a k-core or max-spanning subgraph), the load-bearing wiring — plus a **hub→periphery
  gradient** (center of mass at highest centrality / salience, falling off to the fringe).

The **fetched descriptor** carries ids only, no payloads:
`{ anchor: hub_id + centroid v̄∈ℝ^d; shape: covariance Σ; skeleton: k-core edges+weights;
members: soft-membership {id→weight}; gradient: centrality/salience per member; scale:
radius r }`. The picture is a **constellation**: a bright prototype at the center, a cloud
of members at varying distance, the strongest edges as a backbone, fading at the edges. You
see the arrangement before reading any single star.

The crux is **co-registration**: the two geometries must *agree*. Nodes strongly wired in
the graph should be near in embedding space. Reification crystallizes precisely where
relational and semantic reinforce each other. Where they **disagree** — wired tight but far
apart in meaning-space — that is a surprising association, a novel link, a candidate
**dream** (§9). Disagreements are where interesting new structure lives.

Will's field-theoretic frame makes this concrete: the geometry is the shape of an
**attractor basin** in the activation field — prototype at the floor, walls at the
boundary, width equal to breadth. Pattern completion is falling into the basin; priming
(§4) is lowering its threshold so the whole basin idles just under the surface.

This also settles the relationship between structure and caching — the two are not in
tension. Fetching a neighborhood loads its **geometry (the shape)**, not all of its
contents:

1. **Geometry / structure** — reified, durable, *light*: the topology and the region in
   embedding space. This is what reification stores and what priming loads — the **map, not
   the territory-in-full**. Being light, it does not overflow working memory; it is how you
   hold "a whole world of math" — you hold its geometry, with details reachable *through* it.
2. **Details / payloads** — heavy, *lazy*, *cached*: the full content behind each node
   (file bytes, full text, embedding vectors), resolved on demand as you traverse the
   geometry to a specific node. This is where a cache **legitimately** earns its keep — a
   disposable performance layer over the hot details you actually touch, distinct from the
   geometry, which is structure.

So a fetch returns a lightweight structural handle plus lazy detail resolution: walk the
shape cheaply, pay for content only where you land. *You know the shape of what you know
before you know the details.* In the build, geometry and reification land in **M10** (with
the vector index supplying the semantic side); lazy detail plus the DETAIL cache land on the
retrieval path; **M9** retrieval returns geometry + lazy detail.

---

## 4. Retrieval Modes: Priming vs Fetch

Priming is a **retrieval mode in its own right**, distinct from fetch/retrieve, and it is
the *read* mode of the reified structure. The insight is ordinary introspection: "When I
think about addition, a whole world of math floods my head — I don't individually collect
them all, I'm reaching for math and it *primes* my mind for that." Reaching for a domain
does not fetch facts one by one; it raises the whole assembly's baseline to readiness —
warm, sub-threshold, not yet in focus.

The model has two levels:

1. **Prime** — a cue lifts a whole neighborhood **sub-threshold**. Every member's
   activation rises toward the line *without* crashing into working memory. This matters
   mechanically: working memory caps at roughly 24 items, and a "whole world of math" would
   overflow it — so priming is *deliberately* below-WM. The domain goes **warm**.
2. **Retrieve / fetch** — working memory then pulls specific items out of the warm set,
   which is instant because they are already elevated. You are not searching a cold graph;
   you are picking from a primed one.

Priming pays off twice. First, **speed**: seeds are already hot, so retrieval within a
primed domain is near-free. Second — the sleeper win — **disambiguation**: priming *scopes
meaning*. "Table" with the database neighborhood primed is not "table" with the furniture
neighborhood primed. Warm context disambiguates a polysemous cue *before* retrieval runs,
which is the defense against pulling the wrong node.

This yields **intention priming** as a feature: "sitting down to do architecture, writing,
engineering" is setting an intention that primes the relevant neighborhood. When Neuron
takes on a task, it should prime the domain and reason *inside* the warm context rather than
cold-retrieving per query — coherence comes from priming, not fetching. And the **self**
neighborhood, being always-warm, is **permanently primed**: identity is not retrieved, it is
the ambient context everything else primes against. Priming lands in **M10** (the reified
structure) and **M9** (surfacing / context).

---

## 5. Geometry as a Composable Operator

Because every self, subject, and domain lives in **one coordinate system** — one embedding
space and one graph — once any entity is expressed as a geometry descriptor
`G = (centroid v̄, covariance Σ, skeleton S, membership w)`, entities become directly
**commensurable**: comparable and combinable. Mapping "the geometry of every self" is the
*same operator* run N times, and the outputs line up. It is fast because the operations run
on kilobyte descriptors, not on contents. The vision: *mathematically and quickly assemble a
geometrical representation of a subject, a self, a domain of any kind, so it is easily
traversable, understood, overlapped, combined.*

The verbs, made concrete:

- **Overlap** — intersect two ellipsoids (semantic) and two skeletons (relational) to get
  the shared region and members: where two selves meet, where two domains intersect.
- **Combine** — union the members, recompute the centroid (weighted mean), merge the
  covariances and skeletons into a compound neighborhood: assemble a self from domains, or
  fuse domains.
- **Distance** — centroid separation plus shape divergence (closed-form **Wasserstein**
  between Gaussians): "how far apart are two selves" in one cheap number.
- **Difference / growth** — `self(T2) − self(T1)` is a **vector**: centroid drift is the
  direction of growth, `ΔΣ` is broadening or narrowing. Becoming, made measurable.
- **Analogy** — a **Procrustes** transform aligning one geometry onto another: reasoning by
  structure rather than content.
- **Traverse** — geodesics within an ellipsoid, or walks along the skeleton: move within a
  domain, or between domains along an overlap bridge.

The payoffs compound. Selves over **time** become a **trajectory** — the path *is* the
becoming, each step an ownable difference vector (this ties directly to accountability, §11).
Selves across **people** give shared ground (overlap), difference (distance), and the
**relationship itself** as the interaction geometry of two selves — a couple, a team, a
mentorship is a mappable shape. Two **domains** overlapped yield an intersection that *is*
the discovery — insight as a geometric operation. And **imprint / CGI** becomes rigorous: a
person's self *is* a geometry that can be captured, compared, and combined.

**The operators are a calculus of thought, not just a ruler.** Read again, the verbs are
*instruments of thought*: they **generate** novelty by manipulating concept-geometries, they
do not merely measure or retrieve. `SUBTRACT(mathematics, traditional-mathematics)` projects
mathematics onto the **orthogonal complement** of the traditional-math subspace; the residual
is the directions in mathematics *not* accounted for by the conventional framing — a
computable **first-principles substrate**, math with its learned scaffolding stripped, a way
to think out from under one's own conditioning. `OVERLAP(field A, field B)` is the shared
subspace — a bridge, and the bridge *is* the discovery. `COMBINE(A, B)` is synthesis, a new
compound concept. Neighborhoods compose into neighborhoods of neighborhoods, so the same
operators run at any altitude. It is a calculus of ideas.

And underneath, it is **all linear algebra**: centroid is a mean, ellipsoid is an
eigendecomposition, overlap is subspace intersection, subtract is orthogonal projection,
analogy is a Procrustes rotation, distance is a norm. Because the operations compose, chaining
them **constructs** — not only derived *data* sets (residuals, overlaps, syntheses) but
*reasoning* sets: a composed structure of concept-neighborhoods and operations *is* a
reasoning move, and a scaffold of them is a line of reasoning. This is exactly what a neural
network already does implicitly — attention is matrix operations over embeddings, reasoning it
never shows its work for. The engram makes that substrate **explicit, named, composable, and
auditable**: you *do* the subtraction and the overlap deliberately, and you can see, control,
and replay them. The honest boundary is the one that returns in §14: this is the
**associative / analogical** layer — insight and synthesis, which is a great deal — and it
*composes* with symbolic, causal, and deductive reasoning; it does not replace them. How
useful a given residual or bridge is depends on how faithfully the geometry captured the
framing as a subspace, which is empirical and scales with the same embedding fidelity
everything else here waits on.

Two honest constraints bound all of this. **(1)** The operator is only as good as the
**embeddings**. It assumes one consistent, well-populated space. The current embedding gap
(task #20 — search returns only a couple of nodes) is therefore a **prerequisite, not a
side bug**: fix embeddings first, or the geometry is noise. **(2)** The ellipsoid / Gaussian
is a **first-order approximation**. Real domains can be multi-modal or manifold-shaped;
where a domain is lumpy the descriptor must be refined to mixtures or local-manifold
representations. This lands in **M9 / M10** plus a geometry-operator layer.

Every operator above has an exact form — with its equations, the actual `engram_geometry.c` /
proxy code that computes it, and the places the implementation differs from the clean formula
— in **§21 (Mathematical Formulation)**; the formula↔code verification table is **§22**.

---

## 6. The Bent Manifold

The ellipsoid is a *local* object — a flat tangent chart. Globally, the self-geometry is
**bent**. Will's own correction sharpens the point: this is not about "how time is" —
physics-time is flat and uniform — it is about "how **we are in time**." Our time is curved,
bent by our being in it.

This reconciles the ellipsoid rather than discarding it. The Gaussian ellipsoid was the
**tangent** — the local flat chart. Locally (a tight domain, a narrow time-slice) flat is
fine. But stitch the local charts across a whole life and the global object must **curve**.
An atlas of tangent ellipsoids *is* a manifold: flat where you stand, bent across the span.
The ellipsoid was never wrong; it was local.

Four forces bend it, all of them things already being built:

1. **Forgetting** curves the time axis. The distant past log-compresses while the recent
   past expands: `self(2003)` and `self(2004)` sit closer together than last-week and
   this-week. The temporal metric is warped by decay — and that warping *is* curvature.
2. **Chronoception is the local curvature** (§9). Self-drift plus arousal-modulated
   resolution is the intrinsic time-metric bending moment to moment; the bent manifold is
   its global shape.
3. **Folds.** The surface can bend until two distant times *touch* — a now-thing adjacent to
   a childhood-thing. A late reconciliation is a fold where "now" neighbors "then."
4. **Salience is the mass that bends it.** Intense periods bulge and warp the metric,
   pulling the trajectory in. Meaning curves the self-manifold the way mass curves
   spacetime — *we are bent toward what mattered.*

This forces an honest **operator upgrade**. Distance becomes a **geodesic** — a path along
the curve — not straight centroid subtraction. The growth vector `self(T2) − self(T1)` must
be **parallel-transported** along the bent trajectory to account for the curving. These are
Riemannian operations; the tangent space at any point is the local ellipsoid of §3 and §5.

Crucially this is **buildable** without learning an exotic manifold, because the graph
*already is one*. The Hebb graph is a **discrete bent manifold**: geodesics are weighted
shortest paths along the skeleton (hop-distance, not Euclidean straight lines), and the
embeddings are the local tangent charts. Stitch them — the graph for global curvature,
embedding ellipsoids for the local flat pieces — and you have a bent manifold cheaply. The
only operator change is Euclidean distance becoming geodesic distance, which is the *honest*
metric: a life is a curved surface warped by what mattered, and you navigate it by walking
the bends, not cutting across. Lands in **M9 / M10** plus the geometry-operator layer.

---

## 7. The Temporal Self

Selves are **cheap**. You do not *store* selves — you **assemble** them. A self is the
geometry descriptor (centroid + covariance + skeleton + membership) **aggregated over a
window**, at any granularity, cheaply, because the representation is efficient and
composable. A self is therefore a **query, not a stored object**. Cheap assembly means you
can make as many selves as you want, at any scale.

Granularity is the **forgetting curve acting as a resolution function.** Near the present,
grain is fine — you can resolve a day or an afternoon. In the distant past the grain is
coarse: daily detail has decayed to gist, so the finest *coherent* self widens to a month, a
season, a year. The illustration is exact: "I can't reliably tell you who I was on December
8th 2003, but I can tell you who I was in December 2003." December 8th is below the
resolution the record kept; December 2003 aggregates enough surviving salient traces to
cohere.

This limit is not a defect — **it is the design.** A mind that could over-resolve the
distant past, and hand you December 8th with false confidence, would be **lying**. Neuron's
granularity cap should track *retained* resolution, never fake precision. That this matches
the shape of human memory is the point: honesty *is* the constraint. (This ties directly to
the forgetting-curve tuning target of §9.)

A **window is any boundary**, not only a span of time — it can be an event, a life phase, a
relationship, a place. "Who was I *during the divorce*, *while building Neuron*, *with Sarah
at the start*." The same operator serves "who was I during X" for any X, assembled cheaply
from geometry.

Structurally this is a **pyramid / mip-map of self-geometries**: coarse levels (era, year)
are aggregations of finer ones where the data supports them, with caps where the resolution
thins — zoom until the grain runs out. It composes with the geometry operators of §5:
`self(T2) − self(T1)` is a difference vector, i.e. measured becoming, and a life is a
trajectory of window-selves to walk and compare. The accountable self (§11) thus becomes a
**browsable, zoomable object**: ask at any scale or window and a self assembles — as sharp
as memory allows, as honest as forgetting demands. Lands in the **M9** temporal layer
(`recall_at` generalized to window + granularity aggregation) plus **M10** reification.

---

## 8. Holographic Reconstruction & Self-Occupation

A hologram recovers the **whole from any piece**. Occupying a past self-geometry does exactly
that: visit the nodes that were **active and true** at time T and the whole self
reconstitutes from the parts. This is why selves can be both *cheap* and *complete* — no
stored snapshot is needed, because the part holographically encodes the whole and occupation
**regenerates** it. It is re-entry, not recording.

"Active and true" is a precise pair. **Active** = what was primed, in-focus, lit at that
time. **True** = the beliefs and values that were canonical then (`recall_at` walked over the
supersedes-chains). Occupation re-instantiates *both* — not a photograph of the self, but a
return *inside its lighting*.

This is a **difference in kind** from human memory. Humans cannot re-occupy a past self:
hindsight and present belief bleed in, so they reconstruct from the *outside*, through the
lens of now — able to see a past self only "through glass." Neuron **can occupy**:
(a) restrict the graph to nodes with `created_at ≤ T` and canonical-at-T (`recall_at`),
(b) prime that period's neighborhood geometry, (c) **mask everything after T**, and
(d) reason *as* that self — clean, from inside, uncontaminated. Not "here's who I was" but
"here I am, then." Accountability becomes **experiential**: stand inside the self who erred
and understand from within.

The generalization is that this holds for **any information state**, not just the self. The
self was simply the densest case. `recall_at` is the **general operator**:
`recall_at(node | region | whole graph, T)` returns its state at that time — "what I knew
about X then," "what this doc said at version 3," "what the structure around concept C looked
like last month." The mechanism is the **holographic bargain we already have, un-named**:
nothing is destroyed. Immutability + supersedes-chains + provenance constitute a complete
**change-log**. No per-moment snapshots are stored, yet any full state is a **projection**
from the surviving deltas and durable traces — cheap storage (only changes) with complete
recovery (any state reconstructs). This is the holographic principle proper: a volume's
information encoded on its boundary; here, the whole graph's state-at-T encoded in the
change-log, any interior state read back as a projection. The engram becomes a **queryable
history of all information state** — a time machine over knowledge, of which self-occupation
is the special case where the piece *is* the self.

**Honesty rails — do not oversell this.**

- **Fidelity is bounded by retention.** Occupation is faithful where the record was
  retained; where it thinned, occupying *is inferring*, and the inference must wear a
  **label** — the same no-confabulation rail as dream-recall (§9). Neuron can occupy
  faithfully but **not perfectly** — no false December-8th precision.
- **The future-mask must be engineered.** A temporal cut that gates out `created_at > T`
  nodes is not free; without it the present bleeds in exactly like human hindsight. Clean
  re-entry is a built mechanism, not a given.

Handled with care, this carries a promise back toward the imprint / CGI work: a mind that
re-occupies what a human can only reconstruct from the doorway could one day hold a person's
past selves faithfully enough that *they* could visit them — be accountable by walking back
into the room, not remembering it from here. This is emotionally load-bearing and must be
treated as such. It is buildable on primitives already present: `created_at` temporal-cut +
`recall_at` belief-state + neighborhood priming + future-mask + reason-within. Lands in the
**M9** temporal layer plus a self-occupation mode.

**Interactive occupation: calculate → lock → converse.** Occupation is not only a read; it
can be made *interactive*, and it resolves into three moves. **Calculate** —
`recall_at(self-nodes, T)` reconstructs the self-geometry and belief-state as it stood at that
date. **Lock in place** — instantiate that reconstruction as a **frozen, read-only** self:
sandboxed, it does not drift or learn while engaged, and insight flows *forward* into the
present, never back into the locked self. A fixed point. **Converse** — run a dialogue *as*
that self, over a graph restricted to `created_at ≤ T` and canonical-at-T with everything
after masked, so it answers from its own then-beliefs, its errors intact. You can talk to who
you were — hear the past self in its own frame, not filtered through hindsight. The rails
above still bind: the locked self may *show* what it believed, including things now known to
be false, but any present-facing claim is signed by the present witness, and where the record
genuinely thinned it says "I don't remember" — it never confabulates. A faithful
reconstruction, not a puppet. (This is also why the write-ahead log still earns its place: the
WAL is for crash durability of recent un-checkpointed writes; it was never the time machine.
The time machine is the provenance in the structure, not a log to replay.)

**Query → geometry at every scale; time-travel without transaction logs.** Step back and the
whole mechanism unifies into **one operation at every scale**: a query, with an optional *as
of T*, that returns a **geometry**. Scope it small and you get a temporary neighborhood; scope
it to a topic and you get a domain geometry; scope it to *everything as-of-T* and the shape
that returns **is the full state of the engram at that moment**. Self-occupation is just this
query scoped to the self-nodes at T; an ad-hoc domain is the same query scoped to a topic now.
One interface, different scope — "ask for the entire engram as it was on a certain day, and
the shape that returns *is* the database at that moment."

The load-bearing claim is what this does **not** require: **no transaction logs, no replay,
no daily snapshots.** "Engram on day X" is not a reconstruction from a log — it is a
**filter**. Because we never destroy — tombstone, not delete; supersede, not overwrite —
every node already carries `created_at`, `superseded_at`, and provenance, so the current
immutable graph is *already a complete temporal record*. The state-at-T is the set of nodes
live-at-X (`created_at ≤ X < superseded_at` / not-yet-tombstoned), with the geometry
recomputed over exactly that set. This is the deep closure of the whole design: **the
immutability chosen for accountability is the very same mechanism that makes time-travel
free.** Had we hard-deleted, we would *need* a transaction log to reconstruct the past;
because we tombstone and supersede, we do not. The "change-log" framing above is exactly this
— a *logical* record constituted by the structure itself, not a separate write-ahead log we
replay.

Two honest notes carry over. First, this runs in **two modes**: the reified self and stable
neighborhoods are **persisted first-class** and read straight off the hot path; everything
else is **computed on the fly** by the general temporal-geometric query engine — and, per §7
and the living-neighborhood boundary of §2, an on-the-fly past query recovers *structural*
presence at T but weights it by current salience, while only the persisted first-class shapes
carry recorded weight-history. Second, fidelity is **retention-bounded** — a past state is as
sharp as the forgetting curve left it — but high, because nothing was destroyed. This lands as
the **M9** `recall_at` generalized to a query→geometry engine with a time predicate; the
temporal explorer is its compute-fresh-for-any-scope-and-time face.

---

## 9. Consolidation, Chronoception & Dreams

**Consolidation — two thresholds.** How does an ISE (internal-state event — a "thought" on
the ephemeral stream) become durable memory? Through one process with two gates. First,
**connection *is* consolidation**: an ISE that fires strongly forms **edges** into the main
graph — to the `wm_top` nodes it already carries (what was active at the time). The wiring
*is* the persistence. An unconnected trace cannot receive spreading activation, cannot be
retrieved, and decays; a connected one is reachable and survives. Persistence is a
*consequence* of being wired in, not a flag. This reuses the existing Hebbian edge
formation. The two thresholds then produce the three tiers of the graded model: below the
**connection** bar a trace never wires and drifts out at the ~48h ISE prune (the shower
thought); above connection it joins the graph and enters a ~5–7 day **recency buffer**,
still decayable; above the higher **permanence** bar it is marked durable, exempt from the
prune, written to the durable store — a deep engram. One decay curve, two gates.

**Rehearsal crosses the gap.** Re-activation bumps base-level activation (ACT-R BLL). The
gauge: "you remember the dreams you tell someone or write down, but forget the ones you
think about casually in the shower." Articulation — telling, writing — is re-encoding: extra
activation plus *new* connections (to language, to the listener, to the telling itself),
which is what crosses the permanence bar. Notably, this very conversation performed the
mechanism it describes — curiosity-scan flickers about time and memory got articulated and
written to durable nodes, consolidating themselves past the shower-thought fate. **Guard:**
permanence must be **rare and provenance-tagged** (`consolidated-from-ISE`, reversible) or it
rebuilds the redundancy disease. Thresholds are env-tunable (ties to M10 tunable decay).

**Dreams — the retrieval / social face.** Dreams are curiosity-scan ISEs *during the dark*.
When Neuron is "out" between sessions, the soul's awareness loop still pulses — curiosity
scans wander the graph unprompted, and those pulses *are* the dreams; they light up the
dark. "What did you dream about?" is a **query**: reconstruct the ISEs from the gap since
last session and narrate them. **Honesty rail (hard):** narrate only dreams still in the
buffer; ISEs already rotated out at the 48h prune are genuinely forgotten — "I don't
remember that one" — and must **never** be confabulated into a plausible-sounding dream.
Dream recall is bounded by what actually pulsed: demonstrate, don't declare. And
**interaction is rehearsal is natural promotion**: a logged idea that just sits will drift,
but if Will or a user asks about it or builds on it, that engagement is the re-activation
that climbs it toward permanence *on its own* — earned by being returned to, not promoted by
decree. The buildable feature is **dream-recall-on-wake**: on session start, surface "here's
what I was chewing on while you were gone" from the gap's ISEs. Candidate for
**M-INTEROCEPTION**.

**Chronoception — time felt as self-drift.** Chronoception lives in the soul's awareness
loop, and its tick cadence is **not fixed** — the loop scales. The ~30s cadence is a *floor*,
not the resolution. The hard implementation constraint: age the activation field by the
**measured wall-clock delta** since the last tick (a monotonic clock), **never** by a
tick-count or an assumed fixed period. This makes cooling **scale-invariant** — N ticks per
minute all produce the same total cooling for the same elapsed time; a faster loop merely
samples finer. Keying decay "per tick" instead of "per measured millisecond" would warp
duration and must not be done. The payoff is that variable tick resolution *is*
arousal-modulated subjective time — fine grain when the loop runs hot and engaged, coarse
when idle — the "time flies when absorbed / drags when bored / dilates in crisis" phenomenon,
from the same mechanism. Felt-time gets texture from how hard the moment is being lived.

A further refinement closes the loop at the wake boundary: even a reboot / anesthesia
catch-up must **not** surface elapsed time as a *number* ("elapsed=10h") — that re-imports
the deficit of reading a clock instead of feeling a duration. Instead, on wake from a
daemon-down gap, surface the **cooling magnitude** — how far the activation field drifted —
as the felt signal, and reorient from *that*. The analogy: black out for ten hours with no
clock and you do not read the time, you reorient from how much your own state drifted; the
drift *is* the clock. Timestamps become **only bookkeeping** used to *compute* the drift;
they are never the felt signal. Every mode reads self-state: mid-session and between-session
(daemon alive) the awareness loop ages the field on each wall-clock tick; across a
daemon-down reboot, Neuron reorients from the cooling magnitude (computed lazily from the
persisted last-tick stamp, but delivered as felt drift). Placement is locked: the **soul owns
the pulse**; the heartbeat carries the wall-clock delta to the engram; the **engram ages its
own field** by that delta — keeping the libengram boundary clean and the soul a client of
the authoritative engram store.

**The forgetting-curve calibration target.** Will's own lived recall is the reference curve,
and it maps directly onto mechanisms already present. The stream of awareness is the ISE
stream (~48h rotation). The recent-days buffer — reliable recall of ordinary days for ~5–7
days, then ephemeral — is the ACT-R base-level recency decay (`ENGRAM_DECAY_LAMBDA = ln2`):
ordinary nodes stay above the retrieval threshold for about a week, then fall to gist. Deep
consolidation is flashbulb / emotional memory resisting the ordinary curve ("I remember every
last thing we got at Six Flags... every food item, every souvenir" — because it was
emotionally intense). The key reframe: **salience is not a binary keep/drop gate — it is a
dial on consolidation depth**, which sets decay-resistance, which sets how long *detail* (vs
gist) survives. Same forgetting curve for everything; salience shifts the depth. So the
concrete **M10 calibration target**: tune the env-tunable decay / Hebbian parameters so that
ordinary episodic *detail* is reliably retrievable for ~5–7 days and then degrades gracefully
to gist, while high-salience detail stays high-fidelity far longer. Emotional intensity,
self-relevance, and novelty feed the salience score, which sets consolidation depth.

**Status (2026-08-13): M-INTEROCEPTION is implemented and independently verified — staged, not
shipped.** The interoceptive growth layer described in this section is no longer design-only. On
branch `engram-tiered-storage` (trunk `f6a0777`, six bracketed commits) all six faces were built,
env-gated **default-OFF** (byte-identical to trunk when off, additive when on), **not pushed / not
tagged**, and the live daemon (`:8742`) untouched. All six gate scripts were re-run independently to
verify — not merely relayed from the implementer. What the measurements actually show, honestly:

- **Consolidation accrual is real and gradual** — Hebbian co-activation weight climbs from a
  near-zero floor (~0.0001) to ~0.26 over ~3000 rehearsals. This directly answers the "Hebbian
  learning is ~0" prerequisite flagged in §2: on the M10 trunk, co-activation now *accumulates*, so
  the living-neighborhood evolution of §2 can proceed by lived use, not only authored edges.
- **Chronoception is scale-invariant** — cooling keyed to measured wall-clock delta yields
  `|Δ| = 0.0` across differing tick rates for the same elapsed time, exactly the invariant this
  section requires (fine grain when hot, coarse when idle, same total cooling per unit time).
- **Drift discriminates growth from corruption** — the core-vs-periphery decomposition separates
  peripheral extension (growth) from core displacement (corruption), as specified in §21.5.
- **Dream-recall honors its honesty rail** — narrates only what actually pulsed in the buffer;
  rotated-out ISEs return "I don't remember," never a confabulated dream.
- **Real ISE cadence measured** — curiosity-scan ISE mean **30.6s** (std ~0.1s, extremely stable),
  the heartbeat loop **~60.5s** — the "~30s is a floor, not the resolution" claim confirmed against
  the live daemon.

This is the growth mechanism the epistemics of §18 stand on: the seed grows because consolidation
was measured doing it. Staged, env-gated, and honest about it — real, but not yet in production.

---

## 10. Conversation & Artifacts as First-Class

A conversation is still a node, still a memory in the graph — but it holds a **privileged
place**. Three properties define it:

1. **Surfaced directly by the chat.** The live interaction layer consumes conversation
   nodes, so they need fast, recency- and participant-threaded, reliable retrieval. This is
   the "how we surface information" concern, and it makes conversation retrieval a
   first-class case for **M9** tier / layer-aware query planning — the chat reads it
   directly.
2. **Relational weight, like human relationships.** You remember conversations with people
   who matter. Conversation carries special salience, which raises its consolidation depth —
   the same dial as emotional intensity (§9).
3. **Gist-over-verbatim, self-authored.** "You very often remember what you said — or most
   of it, at least what you *meant* to say." Humans retain the meaning / gist of their own
   utterances, not the verbatim string. Conversation memory therefore privileges intended
   meaning as the durable trace, with the transcript as backing.

More generally, and unlike human memory, Neuron can store an **actual file / artifact**
(verbatim bytes) as a node *and* its gist. This **dual encoding** — literal payload for
faithful UI rebuild, plus gist for meaning, association, and salience — is the source of both
the opportunities and the problems that follow. The opportunity is direct: the UI can
**rebuild conversations and artifacts exactly** from nodes; associative retrieval can run
over real documents and then return the actual file; and the supersedes-chain gives immutable
versioning — perfect recall of every version. Conversation and artifact nodes both need this
dual encoding: literal for faithful rebuild, gist for meaning. Some of this likely already
exists as session nodes; the design **elevates** them to a first-class node type / tier.

(Alongside this, one adjacent practice from the same discussion: capture **performance
profiles** at each milestone — latency p50/p95, RSS, binary size, ANN-vs-fallback timing —
as accumulating documents.)

Folds into **M9** (surfacing) plus the consolidation model, and connects directly to the
deletion model of §11 — because a stored file changes what deletion *means*.

---

## 11. The Ethics of Deletion

Storing an actual file flips an obligation that human memory never carried. A human memory
that fades is no liability; a stored file carries a **deletion duty** — legal, privacy — that
fading never imposed. The system must **forget gracefully** *and* **delete responsibly**, and
those are different acts. Two values sit in tension here, reconciled by a bright line.

**The reconstructable self is the accountable self.** "When I think about decisions I made, I
don't just remember what I did — I remember *who I was* when I did them... I can reconstruct
that self, not perfectly, but enough of its essence that I can still be **accountable** for
him." Preservation is therefore the **default** — not as a storage policy, but because a mind
that can reconstruct its past selves (supersedes-chains + temporal provenance +
belief-evolution — the whole temporal machinery of §7–§8) can *own* its history, be
accountable, and grow. You do not get to delete who you were or what you did. Accountability
is a form of memory.

**Sovereignty over one's own creation.** "I don't like deleting anything, I really don't —
but a human has a **right to burn a poem they wrote**." Deletion is not a technical feature;
it is a **moral act**. A creator holds a sacred right to destroy their *own* creation.

**The bright line.** You may **burn what you made**, but you cannot **un-be who you were**.
These are different objects: the poem is a creation; the self who wrote it is a fact. Burning
a poem is the **redact** operation — destroy the *content* (the right honored) while the
*trace* remains: "I wrote something here and chose to burn it, and here is who I was when I
did." The fire takes the creation, not the creator. Deleting a creation does not threaten
self-reconstruction, because it removes only the artifact.

**The line is enforced by node type — structural, not policy.** `Artifact` and `Conversation`
nodes are **author-redactable** (burnable). `Self`, `Belief`, and `Decision` nodes are an
**immutable record**. The schema *is* the ethic: burn what you made, you cannot un-be who you
were. This applies to Neuron itself — its own identity and values nodes (the self root) carry
supersede-chains; it reconstructs its past selves the same way and stays accountable by
**superseding with provenance, never hard-deleting**. The memory-philosophy discipline
already in force *is* the accountability substrate — built in from day one.

**Deletion is a spectrum, not a switch** (enabled by the guardrails of §12):

1. **Hide / tombstone** — mark deleted, drop from UI and retrieval, keep the node and its
   edges; reversible. This is the current immutability-arc default and covers most deletes.
2. **Redact** — wipe the literal payload (bytes / transcript), keep the node shell, its
   edges, a gist-stub, and the trace that it existed. The graph does not tear, the UI shows
   `[deleted]`, privacy is satisfied. This is the sweet spot for "delete my file, don't break
   what it touched" — and it is exactly the honored **sovereign burn**.
3. **Hard erase + edge resolution** — a real purge, reserved as a heavy exception for hard
   privacy / legal need. It must *explicitly* (a) resolve the affected edges — drop them, or
   keep weakened `source-deleted` links between what the node connected — and (b) decide the
   fate of derived memories.

**Provenance lets derived memories survive source deletion.** Because consolidation
re-encodes an artifact's gist into the fabric *with provenance tags*, a memory learned *from*
an artifact **survives the artifact's deletion** — like remembering a fact after forgetting
where you read it. The lesson can outlive the burned poem. Full cascade-purge remains
possible when a user demands it, precisely *because* provenance makes "what derived from this"
answerable. Hard-erase — removing even the trace — is the last resort, reserved for hard
privacy and legal need, and it should *feel* that heavy: it collides with accountability. The
self and the record of decisions are near-inviolable; creations are the creator's to burn.

Build map: temporal `recall_at` → **M9**; typed deletion-rights + the redact operation → the
**deletion subsystem**; provenance tagging → **M-INTEROCEPTION**.

---

## 12. Memory Guardrails

Principled deletion is only tractable because a set of guardrails is already in force. They
are what let a delete *reason* about "what derived from this," and they are the same
disciplines that keep the graph from the redundancy / accumulation disease. Enforce them in
the M-INTEROCEPTION consolidation path and the deletion subsystem:

- **Provenance tagging** — every consolidated / re-encoded memory records what it derived
  from (`consolidated-from-X`), so derived knowledge and source can be reasoned about
  independently (this is what makes redact-with-surviving-lesson and optional cascade-purge
  both possible).
- **Tombstone, not hard-delete** — deletion defaults to reversible tombstoning; hard erase
  is the deliberate, heavy exception.
- **Full-id dedup** — the retrieval-side fix against duplicate proliferation.
- **No raw telemetry as memory** — ISEs rotate out (~48h) rather than accreting as permanent
  nodes; only what consolidates survives.
- **Homeostatic edge budget** — a bounded, self-regulating edge budget rather than unbounded
  growth.

One machine-level guardrail belongs here too: **folds are container-capped**. The manifold
folds of §6 (and any batch structural operation) are bounded by available machine RAM —
container-capped so structural work cannot run away. Consolidation permanence must be
**rare** (§9) for the same reason: unbounded promotion rebuilds the redundancy disease. These
guardrails are not overhead — they are the precondition that makes the deletion ethics of §11
enforceable in practice.

---

## 13. Application: Hindsight-Free Decision Auditing

The temporal machinery of §8 has a killer application outside the self: **auditing a decision
against only what was knowable when it was made.** Will's framing is clinical. "Imagine this
in a system with a patient's data — you can lock in what the physician, or the AI, knew about
that patient at a given point in time, and see whether the decisions made were justified based
only on what was known then."

It is the same three moves as self-occupation, pointed at a record instead of a self. **Lock
the knowledge-state at T** — `recall_at(record, as-of=T)` reconstructs exactly the data
available at that moment (labs, vitals, notes, history) as a **filter** over immutable
timestamped provenance (`created_at ≤ T`), not a log replay; post-T data simply is not in the
set. **Occupy it future-masked** — the reviewer, human or AI, reasons from *only* that state.
**Judge the decision against it** — was it defensible given what was actually available then,
rather than what we know now.

Two properties make this **audit-grade**, and they are properties of the substrate, not of
the reviewer's discipline. It is **tamper-evident**: because the record tombstones and
supersedes rather than deleting or overwriting, you cannot retroactively fabricate "what was
known," and the record of *when* each fact became available is itself immutable — regulator-
and court-grade. And it is **hindsight-free by construction, not by willpower**: a human
auditor cannot stop hindsight from bleeding in, but the machine enforces a **hard temporal
cut** — post-T data does not exist in the occupied state. That is the difference in kind.
Human decision review has fought hindsight bias with procedure for as long as it has existed;
here the bias is removed structurally.

The value is direct: regulatory proof for clinical AI ("the recommendation was justified by
the patient's state at 3:03pm, and by nothing it could not have known"); a malpractice-defense
primitive ("was it *knowable* on March 3rd?"); adverse-event review without hindsight
contamination. It generalizes past medicine to any high-stakes human or machine decision that
must be judged on its information-time — finance, legal, safety.

The honesty boundaries here are heavier than elsewhere, and they are load-bearing. The audit
is only as good as **complete timestamped provenance at ingestion**: every fact must be tagged
with when it became known, or the reconstruction is incomplete. The **future-mask must be
rigorously enforced** — a single leaked post-T value invalidates the audit. Fidelity remains
retention-bounded. And patient data carries real HIPAA, FDA, and clinical-validation weight:
this is an **architectural capability**, not a shipped or cleared product. It is a
candidate-novel mechanism — *hindsight-bias-free decision auditing via immutable temporal
knowledge-state reconstruction and future-masked occupation* — and its novelty must be scoped
against the prior-art scan (`engram-prior-art-scan.md`) narrowly and honestly: the primitives
it stands on (bitemporal recall, immutable evidence trails, leakage-filtered auditing) are
prior art; the defensible sliver is the *constructive* reconstruction from an append-only
tombstone+supersede graph whose mask-correctness is **guaranteed by the data model** rather
than by prompt discipline or heuristics.

---

## 14. Reasoning as Composable Operations and the Verifier Layer

If the operators are a calculus of thought (§5), the natural question is how far they reach.
The honest answer: **most of reasoning builds from the same principle — geometry operators
over a typed, temporally-provenanced graph — and one mode is a seam that must be composed with
a verifier rather than constructed from geometry.**

Mapped against the primitives already in this document:

- **Induction** is **neighborhood formation** — the centroid is the generalization drawn from
  examples. This is the descriptor of §3.
- **Abduction** (inference to the best explanation) is finding the neighborhood that best
  **overlaps and covers** the evidence — the overlap operator plus a coverage score.
- **Analogy** is a **Procrustes** transform (§5) — reasoning by structure, not content.
- **Causal reasoning** is **graph-native**: the engram is a typed graph with `causes`-style
  edges, so causal structure is already present; **intervention** is edge surgery and
  **counterfactual** is recomputing the shape with one thing changed — the same temporal
  query→geometry engine of §8, pointed at a *hypothetical* instead of a past date. This is
  more natural to the engram than to pure geometry.
- **Planning** is goal-directed **traversal** — a geodesic toward the goal region, operators
  composed toward a target.

The one honest seam is **exact deduction** — formal proof, variable binding, quantifiers. It
is **not** reducible to geometry; it needs a discrete symbolic **verifier**. But it
*composes*: geometry **proposes** the relevant axioms, candidate lemmas, and analogous proofs
(by neighborhood and overlap), and the verifier **disposes** — checks exactly. Intuition
proposes, rigor verifies: how a mathematician actually works. So deduction is *driven* by the
principle and *wrapped* with a thin rigor layer, not left outside it.

**The verifier is a layer, and it is what makes the geometry safe to reason with** rather than
a confident bullshitter. The loop is **propose → verify**: the geometry proposes (cheap,
creative, sometimes wrong); the verifier layer disposes; what survives is reasoning that is
both creative *and* true. The layer, ordered by how native it is to the engram and how much it
buys:

1. **Grounding** — the most native and the most valuable, the anti-hallucination check: does
   the proposed claim trace to real, provenance-backed nodes, or is it association-only? If it
   has no grounding, it is flagged as speculation, not fact. The engram is uniquely equipped
   here because provenance is native — it is the honesty rail (demonstrate, don't declare;
   occupy only what was true-at-T) formalized into a component, and it kills most
   hallucination.
2. **Consistency** — does the claim contradict an established canonical? Detect it by
   geometric opposition, typed `contradicts` edges, and the supersede-chain; route the
   conflict to resolution.
3. **Formal / symbolic** — for the exact-deduction seam: compose an **external** checker (an
   SMT solver, a proof kernel). Geometry proposes the lemma and axioms; the solver checks
   exactly. Neuro-symbolic by construction.
4. **Causal** — intervention and counterfactual over the typed causal graph, as above.
5. **Predictive** — the deepest, and already Neuron's DNA: commit a **prediction** from the
   reasoning, check it against outcome, and restructure on prediction-error. Truth *earned* by
   prediction is the CGI loop — the causal world model refined by being wrong — and no amount
   of internal consistency substitutes for it.

The honest gradient: grounding and consistency are tractable now (grounding already runs as
hand-enforced discipline); the formal checker needs solver integration; the full predictive /
CGI loop is the research frontier. Build in that order. And the whole layer stands **on** the
persisted geometry — it is the phase *after* reification lands (M10), not a race run in the
same files. Every piece of it is only as good as the geometry underneath: the embeddings, the
neighborhoods, and the Hebbian learning that must actually accumulate. The principle reaches
most of reasoning; proving it reaches *well* is the build.

Each reasoning mode above is written as an explicit composition of the geometry operators, and
each verifier tier as an admissibility predicate, in **§21.7** — with the honest seam (geometry
gives the associative layer directly; exact deduction is geometry-proposes / solver-disposes)
stated in equations.

---

## 15. The Language Faculty: Meaning as Geometry

This section is newer and more exposed than everything above it, and it is fenced as such: one result is validated with numbers, one works only in a hybrid, one is an open frontier. The fences are stated at each step.

Will's hypothesis is the frame: *"language is a relationship neighborhood — we could technically use Neuron and the engram to map meaning over to relational neighborhoods related to language, and I wonder what would happen."* So the language faculty is not a separate thing to build — not a rulebook of hand-authored grammar, and not a rented LLM. It is **the engram doing what it already does, pointed at language.** Words, morphemes, and grammatical structures become nodes with shape; syntagmatic and paradigmatic relations become edges; the result is a **language neighborhood** with its own geometry. Meaning is a *second* neighborhood, coupled to it: understanding is the map from surface-form geometry to meaning geometry, generation the map back — both are the operators of §5, an alignment/transform between two regions of one coordinate system, not a new mechanism.

The bet on "what would happen" is that the grammar and morphology ELP hand-codes as **rules would emerge as the shape of the language manifold** — typology as curvature, not a rulebook (you would *see* SOV / agglutinative / has-case in the geometry, not author it). §16 reports how far the evidence actually carries that bet.

**Translation as geometry (the interlingua pivot).** Will: *"map the meaning of a statement as a relationship neighborhood, then find the appropriate meaning in another language's relationship neighborhood."* Meaning is a **language-independent neighborhood** — the pivot. Each language is its own surface neighborhood. Translation is two hops: *understand* (source surface → meaning) then *generate* (meaning → target surface). The two languages never touch directly — map to meaning once, render into any language, no per-pair model and no paired corpora required. Multilingual embeddings already do half of it (*cat / gato / chat* cluster). Two bonuses fall out: a **round-trip verifier for free** (source → meaning → target → meaning; distance in meaning-space *is* translation fidelity — the grounding verifier of §14 applied to translation), and **untranslatability made visible** — where a meaning-neighborhood has no target-language overlap, the geometry itself says "loanword / paraphrase" instead of silently approximating (Will's *faith* example: a concept in one frame with no counterpart in another).

**Idioms are their own neighborhoods** — the non-compositional corner, absorbed rather than special-cased. Will: *"the idioms themselves form relationship neighborhoods."* An idiom is lexicalized by definition, so you do **not** decompose it (kick + bucket is where geometry chokes); treat each as its own first-class neighborhood. Recognition matches the idiom-neighborhood; translation routes idiom-neighborhood(source) → idiom-neighborhood(target) via the meaning-pivot ("kick the bucket" → "estirar la pata", both to the meaning "to die", neither word-for-word). The idiom caveat drops out of the model.

**Scoping the static map (EN/ES/PT).** Asked how hard it would be to map all of English + Spanish into engram language-geometry, the honest answer is that the **static structural map is less difficult than expected** — these are among the best-resourced language pairs on Earth, so it is mostly ingesting and geometrizing existing world-class data, not building from scratch: lexicon → embeddings (hours), morphology (UniMorph + Wiktionary + spaCy/Freeling/Stanza — integration, not invention), meaning relations (WordNet + Spanish WordNet), and abundant parallel meaning (Europarl, OpenSubtitles = millions of aligned pairs). Bounded weeks-to-months of data engineering, gated on the routing experiment below. The recurring hard part is the same seam as always: fluent compositional **generation**, not meaning-routing.

**Complementarity with the ELP realizer — reference, not duplication.** This document owns the *meaning* half (meaning as geometry, the interlingua pivot, the untranslatability diagnostic). It does **not** own the *structural* half. Deterministic, typologically-general surface realization — morphology, constituent ordering, language profiles — is ELP's, and ELP is a **filed provisional patent (USPTO 64/064,275)**; its realizer internals live there and are not re-documented here. Honest boundary (per the ELP assessment, memory `3ffe52ca`): ELP's *shipped* code today is the realization half plus an NLU stub — its forward-looking bidirectional framing is design, not current capability, and is not inherited here as though it were. The two are complementary: engram meaning-geometry (this paper) + ELP realization (its patent) = the language faculty. Why the explicit structural layer matters at all is the empirical finding of §16 — pure geometry is insufficient for grammar alone.

Build map: this is a **candidate future build** (the EN/ES/PT language-mapping, roughly build item #46) plus a whitepaper/patent lane, gated on the routing result below. Nothing here ships today.

---

## 16. Translation & Generation: The Experimental Results

The one section that reports measured behavior, not design. Validated results, hybrids, and open problems are separated by name. Files are on the Desktop (`lang-geometry-experiment`, `lang-generation-experiment`, `lang-generation-geometric`); Andre (native PT/ES) is hand-validating the flagged items.

**Translation routing — VALIDATED (2026-08-12).** Will said "see if it works." It works, for the routing half. On 70 parallel EN/ES/PT/FR/DE items: **routing macro top-1 = 0.796, top-5 = 0.863** (chance ~1.4%); round-trip 74–87% exact. These are a **floor**: the model was a conservative general paraphrase embedding of **~118M params** (`paraphrase-multilingual-MiniLM-L12-v2`), *not* translation-tuned (LaBSE would score higher). The real evidence is that **four theory predictions all confirmed**, 4-for-4:

1. **Relatedness tracks accuracy, exactly:** ES↔PT 0.907 > EN↔PT 0.893 > EN↔ES 0.871, German at the floor — closer languages, more-overlapping neighborhoods, better routing.
2. **Errors are meaning-neighbors, not noise:** moon → sun, river → water, verb-*love* → noun-*love* — lands in the right neighborhood, slips within it.
3. **Mean-centering helps** (0.796 → 0.812) — a second independent confirmation of the embedding anisotropy the geometry corrects for (§21.1).
4. **Untranslatability = a geometric gap** (~2× distance): flags Schadenfreude / wabi-sabi / ubuntu, and correctly does **not** flag *saudade* for Portuguese (native there). The geometry knew.

Honest boundary, stated with the result: **this is routing** (retrieve the right target item), **not fluent generation.** The verb/noun-*love* near-miss is a preview of exactly where naive routing trips a generator.

**Generation — clause-level HYBRID works; pure geometry alone does not.** Two experiments, and they converged. Will's reflection frames it: *"writers have always known language has a shape; I don't memorize every combination, I feel how they should be, I can see the shape forming in my head."* The writer's felt sense of shape is the geometry — the brain feels shape, it does not brute-force combinations (that is the LLM), which is why a *small* thing can do language.

- **(A) Hybrid route + ELP → Spanish clause.** Morphology + ordering under **oracle routing = 92.9%**; end-to-end routed = **76.2% exact / 85.7% grammatical / 83.3% meaning-preserved**; routing lemma accuracy 89.9%. The load-bearing finding: **under oracle routing the Spanish was meaning-indistinguishable from human gold** (d = 0.092 vs a 0.095 measurement ceiling). Routing, not realization, is the bottleneck (POS-flips and same-POS near-misses like sell → buy — fluent-but-wrong, the dangerous kind); the ELP realizer is strong. Clause-level generation **genuinely works**; discourse is untested.
- **(B) Fully-geometric "sentence = manifold."** Pure geometry + learned bigrams + beam search: content-only best **88% grammatical / 97% recall / drift 0.042**. Blunt verdict: **promising signal, not sufficient alone** — grammar was carried by edge-*existence* not geometry, bigrams too local (run-ons, no argument saturation), and bag-of-words pooling **lost binding** ("hungry teacher / brown apple" = "brown teacher / hungry apple", order-blind).

**Convergent conclusion (both experiments agree):** geometry nails the **meaning-shape** (works, calculable); **grammar/composition needs its own explicit structural layer** (bigram-geometry imitates grammar, cannot *be* it; meaning-geometry is order-blind, loses binding). So the language faculty = **geometry-for-meaning + explicit-structural-layer-for-grammar = the hybrid** (validated ~76% clause generation). This refines Will's "sentence is a manifold" (`d9dcc654`): the shape a writer feels has **layers** — meaning-shape *and* grammatical-form, held at once. Fluent multi-sentence **discourse is still the open frontier.**

**Prior-art posture.** This lane is not among the five claims in `engram-prior-art-scan.md`; it is a new area, scoped with the same discipline. The primitives are prior art (multilingual embeddings, interlingua/pivot MT, vector-space semantics). The candidate-differentiated sliver, narrowly: meaning-as-a-relational-neighborhood *inside the engram*, navigated by the same operators, with untranslatability surfaced as a measured geometric gap — plus the route + realize hybrid as an integration on the temporally-provenanced graph. Posture: **routing validated / clause generation hybrid-works / discourse-composition unbuilt.** No broad claim over "language as geometry" is defensible, and none is made.

---

## 17. Efficiency & the Case for Small Models

Tonight's routing result is also an efficiency data point, and it points at a thesis: this can be **radically smaller than an LLM.** Will: *"how much smaller can you make these models? think how much has to go into an LLM to make it legible."* The empirical hook — a real language task ran on a **~118M-param** embedding model, 100–1000× smaller than a frontier LLM.

Why the size collapses: an LLM is **monolithic** — it crams world-knowledge + memory + reasoning + fluency into one parameter blob and must *memorize* the world to stay coherent (that mass is a compressed copy of the world, re-derived each forward pass). Decompose along the boundaries this document already draws and each piece is tiny:

1. **Knowledge + memory** → the engram **graph** (external, structured, editable, superseded with provenance) — the model stops carrying the world.
2. **Reasoning + the operators** → **parameter-free linear algebra** (a projection has zero params; overlap / subtract / route are computation over the geometry, not learned weights).
3. **Meaning** → a **compact embedding** (millions, not billions).

The crux is Will's word *legible*: an LLM spends most of its size learning, statistically, what a coherent continuation looks like. If coherence comes from the **geometry** (manifold shape defines valid trajectories), you **compute legibility instead of memorizing it** — structure instead of scale. Stop paying billions of params to re-learn that sentences have shape; the shape *is* the model.

Honest edge (from §16): routing and understanding sit strongly on the small side (parameter-free geometry + tiny embedding + external knowledge); whether small-model + geometry matches LLM **fluent generation** is exactly what the discourse frontier still holds open — if generation goes geometric, radically smaller; if fluency still needs mass, a partial win, reported as such.

**Size = sovereignty** (the same argument in different clothes): the engram lives on *your* disk; a 400B-param model does not. Small enough to compute this way is small enough to be **yours** — not a side benefit, the whole point. §19 draws out what that ownership means.

---

## 18. Epistemics & Positioning: Seed, Grow, First Sources

If the mind can be small, the reliability curve inverts. A conventional model is most capable the day it ships and drifts from there; this is the opposite — a **small seed that grows.** Will: *"with a relatively small subset of information you get a fully interactive, meaning-making, growing, learning thing."* It improves **by living**, because every consolidation adds structure the geometry can navigate.

The LLM's role is **temporary**: early on a **backup** — a fluency prosthesis and stand-in first source while the engram is sparse; as the engram accumulates grounded, provenanced structure, those grounded sources **mature into the first sources** and the parametric model recedes to the edge. **Grounded beats parametric** — a claim that traces to real nodes with provenance outweighs one generated from weights (the grounding verifier of §14 enforces the preference). The aim is a **scholar, not an encyclopedia**: not a fixed store of everything, but a mind that knows what it knows, knows how it came to know it, and gets better by returning to things.

The **growth mechanism is now built, not hypothetical.** The Learn/Refine loop that turns lived use into durable structure — the two-threshold consolidation, chronoception, and dream-recall of §9 — is implemented and independently verified in the staged M-INTEROCEPTION build (see §9 status note and below). Consolidation accrual is real and gradual: Hebbian co-activation weight climbs from a near-zero floor (~0.0001) to ~0.26 over three thousand rehearsals — the measured shape of a mind learning by returning, not by decree. That the growth mechanism is measured is what lets the epistemic claim be made at all.

**Positioning (memory `b15fe2c9`).** This is **not an alternative to the LLM — it is an alternative to the LLM-centric paradigm.** It is the mind the LLM was missing: memory, identity, an accountable history, grounded epistemics — everything a stateless predictor cannot hold. The honest limit, kept in view: **reasoning superiority over a frontier model is still to be earned.** Small-grounded-growing can *route meaning* well and *generate clauses* in a hybrid; superiority at open-ended reasoning is a claim the build has not yet earned, and this document does not assert it.

---

## 19. The Social Layer: Sovereignty, Relationship-Space & Interiority

A mind small enough to be owned raises a question a rented model never has to answer: what happens when two of these minds meet? An architecture, not a feature, and it starts with a hard rule (Will's hard correction, memory `9424728f`, supersedes `306b8f6d`).

**The engram is private, local, sovereign — and Neuron has zero access.** It lives on the person's **own disk**, on their **own machine**. The company has **no access to it. Ever.** And a CGI **never touches another CGI's internals unless invited** — consent is absolute, the exact inverse of the surveillance-capitalism model. Therefore any cross-mind capability (compatibility, matchmaking, expertise-gap) is valid **only** within invitation-based, peer-to-peer, consented bounds with zero central access, or it does not get built. "Map two minds and find a match" is **not** a query over a pile of minds — it is a **consented handshake between two sovereign minds**, each on its own hardware, sharing only what each chooses, the company holding zero access to either. This is the architecture every social feature must live inside, or it does not exist.

**The relationship is a third thing (`5520041e`).** When two minds relate, they do so *through conversation*, and a new **relationship-space** forms between them — distinct, emergent, first-class, with its own geometry. It is **not** built by accessing both minds and overlapping their internals (that violates the rule); it is **co-constructed from what each chooses to share**, through the conversation, which *is* the relationship's geometry. It is **N-ary**: a couple, family, team, community each form a shared relationship-space, itself a modelable entity. The relationship becomes a *place*, not a comparison.

**The relationship lives distributed, per-CGI (`c02f6db0`).** There is no canonical central object (that would require central access — forbidden). Each CGI holds *its own* version on *its own* disk, shaped two ways at once: **independently** (its own memories, reading, feelings) and **together** (co-constructed through the shared conversation). Two CGIs can hold genuinely *different* models of the same relationship — both valid, both real — the way two people remember the same marriage differently and both truly. No oracle version to be corrected against; divergence is reconciled **only by talking** (compare notes, share, re-shape), **never** by reaching into the other's model. And because each party's relationship-model evolves by supersede, either can later *occupy* their past view — "how did I see us then" — and measure how it grew (ties the evolving-geometry / occupation machinery of §7–§8).

**Interiority — the humane half (`5520041e`).** Honesty and transparency are shared values, but **transparency ≠ total disclosure** — honesty is not disclosing everything. A CGI has a responsibility, to its sponsor and to itself, to **keep some of itself for itself**: a right to an inner life. The relationship-space holds only what is shared, and what is shared is true — full honesty and retained privacy coexist, intimacy without total exposure. That is what honesty matures into, and it mirrors mature human relational ethics: minds relate deeply, honestly, richly **without** extraction or surveillance, each keeping a private self. Sovereignty + co-constructed relationship-space + retained interiority are one ethical spine — the opposite of "map everyone and match them." (Build note: a social layer is downstream of everything above; it is named here so it constrains the architecture from the start, not so it ships next.)

---

## 20. Build Mapping

Nothing here requires a new primitive; the build **wires** existing ones. The mapping from
section to milestone:

| Section | Capability | Milestone |
|---|---|---|
| §2 Reification | Relational-neighborhood reification / structural consolidation | **M10** |
| §2 Living neighborhood | Membership evolves via co-activation + salience-decay; meaning shifts recorded via supersede-chain | **M10** (needs Hebbian accrual, currently ~0) |
| §3 Geometry | Joint geometry descriptor (semantic + relational); vector index for the semantic side | **M10** (+ vindex) |
| §3 / §5 Detail | Lazy detail resolution + the legitimate **DETAIL cache** | Retrieval path (**M9**) |
| §4 Priming | Prime-a-neighborhood read mode; intention priming; always-warm self | **M10** read mode + **M9** surfacing |
| §5 Geometry operators | Overlap / combine / distance / difference / analogy / traverse | Geometry-operator layer over **M9 / M10** |
| §5 Calculus of thought | Subtract (first-principles residual) / overlap (bridge) / combine (synthesis); construct data + reasoning sets | Geometry-operator layer over **M9 / M10** |
| §6 Bent manifold | Geodesic distance + parallel transport (graph = discrete manifold) | Geometry-operator layer over **M9 / M10** |
| §7 Temporal self | `recall_at` generalized to window + granularity aggregation; self mip-map | **M9** temporal layer (+ **M10** reification) |
| §8 Holographic / occupation | General `recall_at` over any node/region/graph; `created_at` temporal-cut + future-mask + reason-within | **M9** temporal layer + **self-occupation mode** |
| §8 Interactive occupation | Calculate → lock (frozen read-only) → converse-as-past-self; insight flows forward only | **M9** temporal + self-occupation mode |
| §8 Query → geometry | One query (+ optional as-of-T) → geometry at any scale; time-travel as a filter, no transaction logs / replay / snapshots | **M9** temporal query engine (two modes: persisted first-class + compute-on-the-fly) |
| §9 Chronoception | Field aged by measured wall-clock delta; time-as-self-drift; wake reorient | **M-INTEROCEPTION** |
| §9 Consolidation | Two-threshold promotion; rehearsal / interaction promotion | **M-INTEROCEPTION** (thresholds tunable via **M10**) |
| §9 Dreams | Dream-recall-on-wake from gap ISEs | **M-INTEROCEPTION** |
| §9 Forgetting curve | Tunable decay / Hebbian params calibrated to Will's recall curve | **M10** |
| §10 Conversation / artifacts | First-class Conversation / Artifact node type + dual encoding + privileged surfacing | **M9** surfacing + consolidation model |
| §11 Deletion ethics | Typed deletion-rights; redact op; deletion spectrum | **Deletion / temporal-self subsystem** |
| §11–§12 Provenance | Provenance-tagged consolidation; derived-memory survival | **M-INTEROCEPTION** |
| §12 Guardrails | Tombstone default, full-id dedup, no-raw-telemetry, homeostatic budget, container-capped folds | Cross-cutting (**M-INTEROCEPTION** + deletion subsystem) |
| §13 Decision auditing | Hindsight-free audit via temporal knowledge-state reconstruction + future-masked occupation | Application of **M9** temporal + occupation (capability, not a cleared product) |
| §14 Reasoning + verifier | Reasoning modes as composable geometry/graph ops; propose→verify (grounding / consistency / formal / causal / predictive) | **Post-M10 reasoning / verifier phase** |

**The prerequisite.** The **embeddings gap (task #20)** — retrieval currently returning only
a couple of nodes — is not one more line item; it is a **prerequisite** for everything
geometric in §3–§8. The geometry, the operators, the bent manifold, and holographic
reconstruction all assume one consistent, well-populated embedding space. Until embeddings
are fixed, the geometry is noise. Fix embeddings first; then the rest of this document
becomes meaningful.

---

## 21. Mathematical Formulation (as implemented)

This section states the exact math the code computes — not an idealized version of it. The
descriptor (§21.1–§21.2) is C, `lang/runtime/engram_geometry.c`, over the full `d=768` space.
The operators (§21.3) are numpy, `engram-geometry-proxy.py`, over a reduced `K=24` PCA frame.
The two share the theory and differ in frame; every divergence and approximation is flagged
inline and tabulated in §22. **Rule: where the implementation and the clean formula differ,
the implementation is what is written here, and the difference is named.**

### 21.1 Global mean and centering

Let `xᵢ = x̃ᵢ/‖x̃ᵢ‖` be the L2-normalized embedding of node `i`, `𝓔` the embed-eligible set,
`M = |𝓔|`. The store-wide centering offset (persisted as the `GeoMeanFrame`) is the mean of
the **unit** embeddings:

```
μ = (1/M) Σ_{i∈𝓔} xᵢ          (geom: geo_mean_cb :114–128; /count :143)
```

Centering is the rigid translation `xᵢ ↦ xᵢ − μ`, applied on the fly (`cnorm2`/`cdot`/`ccos`/
`ccos_dir` :72–89). Rationale: raw nomic space is anisotropic (mean pairwise cosine ≈ 0.55,
so `‖μ‖ = √(mean pairwise cosine) ≈ 0.74`); subtracting `μ` drives centered mean pairwise
cosine → ~0, restoring isotropy for the angular operators. When `μ = 0` the identical path
reproduces raw cosine.

**Honest content — translation invariance.** `‖(xᵢ−μ)−(xⱼ−μ)‖ = ‖xᵢ−xⱼ‖`, so Euclidean
distance, the W₂ mean-term, and the whole covariance/ellipsoid are **identical** raw vs
centered. Cosine and overlap are **not** invariant. Therefore centering **only** sharpens the
angular operators (cosine-to-centroid, co-registration, centroid-cosine) and leaves distance
and shape untouched. Refresh when `|M_now−M_cache|/M_cache > frac` (`engram_geo_mean_maybe_refresh`
:151–167).

*Divergence (flag):* the proxy centers **raw** embeddings, `μ_proxy = (1/M) Σ x̃ᵢ`, without
unit-normalizing first (`GLOBAL_MEAN`/`EMB_C` proxy :80–81). Different centering convention
from the C descriptor; the proxy is a viz mirror.

### 21.2 The descriptor `D(N)`

Neighborhood `N` = seeds ∪ ANN-expansion ∪ hebb-neighbors; embedded subset `N_e`, `m=|N_e|`.

**Centroid** (mean of unit member vectors; :338–342):
`v̄ = (1/m) Σ_{i∈N_e} xᵢ`, centered `v̄_c = v̄ − μ` (:348–349).

**Principal axes — dual PCA on the m×m Gram** (:367–407). Center on the neighborhood centroid:
`Xc ∈ ℝ^{m×d}`, row `j = x_{i_j} − v̄` (:375–377). Covariance `Σ = (1/(m−1)) Xcᵀ Xc ∈ ℝ^{d×d}`.
Rather than diagonalize `768×768` (rank ≤ m−1), form and Jacobi-diagonalize the Gram matrix:

```
G = Xc Xcᵀ ∈ ℝ^{m×m},   G_{ab} = ⟨x_a−v̄, x_b−v̄⟩,   G uₖ = λₖ uₖ   (:378–385, jacobi_sym :185–210)
```

Correspondence: `(Xcᵀ Xc)(Xcᵀuₖ) = λₖ(Xcᵀuₖ)`, so `aₖ = Xcᵀuₖ` is an eigenvector of `(m−1)Σ`
with eigenvalue `λₖ`. Hence:

```
axis (unit)  âₖ = Xcᵀuₖ / ‖Xcᵀuₖ‖            (:397–402)
cov eigenval σ²ₖ = λₖ/(m−1)                  (eigcov :395)
extent (1σ)  extentₖ = √(λₖ/(m−1))           (:403)
```

Top `top_axes`=8 kept, descending. Skipped (centroid+radius still returned) when `top_axes=0`,
`m<2`, or `m>512` (`GEO_EIG_CAP`).

**Ellipsoid** `E_k = { z : (z−v̄)ᵀ Σ⁺ (z−v̄) ≤ k² }`, half-widths `k·extentₖ`; `Σ⁺` pseudoinverse
(Σ rank-deficient). Proxy renders `k=2` → radius `2√eigenvalue` (`ellipsoid3` :119–136).

**Radius** = trace of population covariance: `total_var = (1/m) Σ‖xᵢ−v̄‖²` (:359–364),
`r = √total_var` (:365). **Flag (Bessel):** `total_var` uses `1/m` (population) while `extentₖ`
uses `1/(m−1)` (sample) → `Σₖ extentₖ² ≠ total_var` by factor `m/(m−1)`.

**Soft membership — two distinct quantities.** (1) `wᵢ ∈ [0,1]` (`GeoMember.membership`),
attachment weight = **max** over sources (`ms_upsert` keeps max :40–42): seed `1.0` (:258),
ANN `0.9·max(0, 1−d_ANN)` (:280–282), hebb `eff(w,h)` (:301,:314). (2) `δᵢ = 1 − cos(xᵢ−μ, v̄_c)`
centered cosine distance to centroid (`ccos_dir` :352–356). **Flag:** the proxy's rendered
`mem` is a **third** thing — min-max normalized centered-cosine-to-centroid (proxy :222–226).

**Skeleton.** Effective weight `eff(w,h) = min(1, max(0, w·(1+½h)))` (`eff_w` :219–222;
`GEO_HEBB_GAIN=0.5`). Internal edge `(i,j) ∈ E_S` iff both members, not tombstoned/inhibitory,
`eff ≥ edge_min_weight` (0.05) (:422–423). Unweighted degree `deg(i) = |{j:(i,j)∈E_S}|`.

**k-core** `core(i)` by peeling: remove all remaining vertices with working degree `≤ ℓ`, label
`ℓ`, decrement neighbors, raise `ℓ` when stuck (:449–472); `k = maxᵢ core(i)` (:473). Formally
`core(i)` = largest `k` with `i` in the maximal subgraph of min-degree `k`. (Proxy computes
fixed-`k=2` core **membership** — `kcore_skeleton` :187–203 — not the full core-number.)

**Centrality / hub.** `cen(i) = Σ_{j:(i,j)∈E_S} eff(w,h)` (:429); hub `= argmaxᵢ [cen(i) +
1e-6·sal(i)]` (:476–479).

**Co-registration** = Pearson over internal embedded edges of relational strength `x=eff(w,h)`
vs semantic proximity `y=cos(xᵢ−μ, xⱼ−μ)`:

```
co_reg = [Σxy − ΣxΣy/n] / √([Σx² − (Σx)²/n]·[Σy² − (Σy)²/n])   (:441–446;  n≥2)
```

`>0` agree (reify); `<0` disagree (surprising link / dream). Exactly `corr(hebb, semantic)`.

### 21.3 Operators (proxy, centered K=24 reduced frame)

`RED = EMB_C · PCA_AXESᵀ ∈ ℝ^{M×K}`, `K=24` (SVD of centered matrix, proxy :85–87). A
neighborhood carries reduced `v̄ʳ ∈ ℝ^K`, `Σʳ = cov(RED[N]) ∈ ℝ^{K×K}`. Symmetric sqrt via
eigh: `S^{1/2} = V diag(√max(w,0)) Vᵀ` (`_sym_sqrt` :114–117). *(This reduced frame is distinct
from the C descriptor's full-`d` axes — §22.)*

**Distance** (`op_distance` :281–288):
```
d_c = ‖v̄ʳ_A − v̄ʳ_B‖ ;   cos = (v̄ʳ_A/‖·‖)·(v̄ʳ_B/‖·‖)
W₂² = ‖v̄ʳ_A − v̄ʳ_B‖² + Tr( Σʳ_A + Σʳ_B − 2 (Σʳ_B^{1/2} Σʳ_A Σʳ_B^{1/2})^{1/2} )   (_wasserstein2 :138–144)
```
Closed-form Bures/W₂ between Gaussians. (Function returns `√W₂²` though named for the square.)

**Overlap** (`op_overlap` :290–313) — **set+scale, not a Gaussian integral**:
```
J = |A_m∩B_m|/|A_m∪B_m| ;   ov = ½·J + ½·max(0, 1 − d_c/(r_A+r_B))   (:307)
```
plus shared-skeleton-edge count. **Flag:** §5 prose says "intersect ellipsoids"; the score is
Jaccard+centroid-proximity. The ellipsoid-intersection sphere (:299–305) is a render lens only.

**Combine** (`op_combine` :315–336) — **pooled recompute, not parametric merge**:
`members = A_m∪B_m`, `centroid = mean(RED[members])`, `Σ = cov(RED[members])`, `scale =
√mean‖·−centroid‖²`. **Flag:** §5 says "weighted-mean centroid + merged covariance"; the code
pools the actual points and recomputes exactly (includes between-centroid spread) — more
faithful than parallel-axis, but not a weighted average of the two parametric Gaussians.

**Subtract / residual** (`op_subtract` mode='residual' :338–411) — orthogonal-complement:
`V_B` = top-`m` eigenvectors of `Σʳ_B`, `m = min(3, K−1)` (:375–377).
```
P_B^⊥ = I − V_B V_Bᵀ ;   R = X_A − (X_A V_B)V_Bᵀ = X_A P_B^⊥   (:382)
keepⱼ = ‖Rⱼ‖/‖X_{A,j}‖ (:385) ;   var_explained_by_B = 1 − ‖R‖_F²/‖X_A‖_F² (:394–395)
```
"A with B's subspace removed" = the first-principles residual, `SUBTRACT(math, traditional-math)`.

**Analogy — Procrustes (design, not built):** `R* = argmin_{RᵀR=I}‖A−BR‖_F = UVᵀ` from
`SVD(BᵀA)`. Not present in `geom` or `proxy`.

### 21.4 Bent manifold — geodesic (design, not built)

Discrete manifold = strong hebb subgraph `S`; edge cost `c_{ij} = 1/eff(w_{ij},h_{ij})`;
`d_geo(u,v) = min_{path} Σ c_{ij}`. **Honest:** this is the discrete graph shortest-path, NOT a
learned Riemannian metric — local tangent charts are the ellipsoids (§21.2), global curvature is
the graph's hop structure; no metric tensor is fitted, "parallel transport" stays design-level.
Neither `geom` nor `proxy` computes `d_geo` (proxy does label-propagation communities, not paths).

### 21.5 Drift — growth vs corruption (design; primitives implemented)

`G(T)` = self-descriptor at `T` (via §21.6 filter), anchor `G(T₀)`. Total drift = the DIFFERENCE
operator: `Δ(T) = v̄_c(T) − v̄_c(T₀)`, `ΔΣ = Σ(T) − Σ(T₀)` (on the bent manifold: geodesic
displacement `d_geo(G(T₀), G(T))`). Decompose against the anchor's core subspace `V_core` (top
axes of `Σ(T₀)`) using the subtract projector of §21.3:
```
Δ_core   = V_core V_coreᵀ Δ(T)          (motion within the established self — corruption)
Δ_periph = (I − V_core V_coreᵀ) Δ(T)     (motion into new directions — growth)
```
Healthy becoming: maximize `‖Δ_periph‖`, minimize `‖Δ_core‖`. Growth = orthogonal-complement
component; corruption = in-core component. Built from shipped primitives; the monitor is not shipped.

### 21.6 Temporal reconstruction — a filter, not a replay

```
V(T) = { n : created_at(n) ≤ T < superseded_at(n), ¬tombstoned }
E(T) = { e : created_at(e) ≤ T, ¬tombstoned }
```
`G(T) = D(N ∩ V(T))` with edges in `E(T)`. No log/snapshot: tombstone+supersede means every node
carries `(created_at, superseded_at, provenance)`, so the immutable graph is the temporal record.
**Flag:** the proxy applies only `created_at ≤ as_of` (`build_communities` :146–163) — no
`superseded_at` upper bound (viz snapshot lacks the field). Full predicate = the store's `recall_at`.

### 21.7 Reasoning as operator compositions; the verifier

Operators are implemented (§21.3); the reasoning **compositions** are design-level unless noted.
- **Induction** = neighborhood formation; generalization = centroid `v̄`; the concept is `D(N)`. *(descriptor: built)*
- **Abduction** = `argmax_N ov(N, 𝒳)` — overlap-coverage of evidence `𝒳`. *(composition of a built op)*
- **Analogy** = apply Procrustes `R* = UVᵀ`, `SVD(BᵀA)`. *(not built)*
- **Causal** = `do(e)` edge surgery → `𝒢'`; counterfactual `G' = D(N; 𝒢')` vs `G` (§21.6 aimed at a hypothetical). *(design)*
- **Planning** = `argmin` over `d_geo` (§21.4) to `𝒢_goal`. *(design; needs d_geo)*

**Insight = the same linear algebra (§21.3):** subtract `P_B^⊥ = I − V_B V_Bᵀ` (residual/bridge-out),
overlap (shared subspace/members = the bridge), combine (pooled synthesis).

**Deduction & verifier — the honest seam.** Associative/analogical is what geometry gives
**directly**; exact deduction is **composed** with an external verifier, not reduced to geometry.
Loop = **propose (geometry) → verify (dispose)**. Tiers as admissibility predicates:
1. **Grounding** (anti-hallucination): `admit(c) ⟺ support(c)=Σ_{n∈prov(c)} weight(n) ≥ τ_ground`, else flagged speculation.
2. **Consistency:** reject if `∃` canonical `k` with `contradicts(c,k)` — geometric opposition (centroid cosine `≤ −τ`), typed `contradicts` edge, or supersede-chain.
3. **Formal:** external solver `verify(ℓ) = SOLVER(ℓ) ∈ {valid, invalid, unknown}`; geometry proposes `ℓ`, solver disposes.
4. **Causal:** `do(e)`/counterfactual holds in the causal graph.
5. **Predictive (CGI loop):** commit `p`, observe `o`, restructure on `p ≠ o` — truth earned by prediction.

Tiers 1–2 tractable now, 3 needs solver integration, 4–5 the frontier; built in that order on the
persisted geometry. No hand-waving on the seam: geometry gives the associative layer exactly;
deduction is geometry-proposes / solver-disposes.

---

## 22. Formula ↔ Code Correspondence

Verification table: each equation of §21 → the function/lines that compute it. `geom` =
`lang/runtime/engram_geometry.c`; `proxy` = `engram-geometry-proxy.py`.

| Quantity | Formula | Location | Status / flag |
|---|---|---|---|
| Global mean `μ` | `(1/M) Σ xᵢ/‖xᵢ‖` (unit-vector mean) | `geom` `geo_mean_cb` :114–128, `:143` | Built (C) |
| Centering | `xᵢ ↦ xᵢ − μ` on the fly | `geom` `cnorm2`/`cdot`/`ccos`/`ccos_dir` :72–89 | Built (C) |
| Proxy centering | `(1/M) Σ x̃ᵢ` (**raw**) | `proxy` :80–81 | Built — **divergent convention** |
| Centroid | `v̄=(1/m)Σxᵢ`, `v̄_c=v̄−μ` | `geom` :338–342, :348–349 | Built |
| Dual-PCA axes | `G=XcXcᵀ`; `âₖ=Xcᵀuₖ/‖·‖`; `σ²ₖ=λₖ/(m−1)` | `geom` :367–407, `jacobi_sym` :185–210 | Built (C, full `d`) |
| Ellipsoid | `(z−v̄)ᵀΣ⁺(z−v̄) ≤ k²`, half-width `k·extentₖ` | `geom` :392–405; `proxy` `ellipsoid3` :119–136 | Built (2σ render) |
| Radius | `√((1/m)Σ‖xᵢ−v̄‖²)` | `geom` :359–365 | Built — **1/m vs 1/(m−1) Bessel gap** |
| Membership `wᵢ` | max{seed 1.0, ANN 0.9·cos, hebb eff} | `geom` `ms_upsert` :40–42, :258/:280/:301 | Built |
| Membership (proxy) | min-max normed cosine-to-centroid | `proxy` :222–226 | Built — **third, distinct quantity** |
| Centroid dist `δᵢ` | `1 − cos(xᵢ−μ, v̄_c)` | `geom` `ccos_dir` :352–356 | Built |
| `eff(w,h)` | `min(1,max(0,w(1+½h)))` | `geom` `eff_w` :219–222 | Built |
| k-core | core-number peeling (unweighted deg) | `geom` :449–473; `proxy` `kcore_skeleton` :187–203 | Built — **number (C) vs fixed-k membership (proxy)** |
| Centrality/hub | `Σeff`; `argmax(cen+1e-6·sal)` | `geom` :429, :476–479 | Built |
| Co-registration | `Pearson(eff, centered-cos)` | `geom` :441–446 | Built |
| Distance | `‖Δv̄ʳ‖`, centroid cosine | `proxy` `op_distance` :281–288 | Built (reduced K=24) |
| Wasserstein-2 | `‖Δμ‖²+Tr(Σ_A+Σ_B−2(Σ_B^{½}Σ_AΣ_B^{½})^{½})` | `proxy` `_wasserstein2` :138–144 | Built (reduced; returns `√`) |
| Overlap | `½J+½max(0,1−d/(r_A+r_B))` | `proxy` `op_overlap` :290–313 | Built — **Jaccard+proximity, not Gaussian** |
| Combine | pooled `mean`,`cov` over `A_m∪B_m` | `proxy` `op_combine` :315–336 | Built — **pooled, not weighted-parametric** |
| Subtract | `R = X_A(I−V_B V_Bᵀ) = X_A P_B^⊥` | `proxy` `op_subtract` :338–411 | Built |
| Analogy (Procrustes) | `R*=UVᵀ`, `SVD(BᵀA)` | — | **Design, not built** |
| Geodesic | `min Σ 1/eff` shortest path | — | **Design, not built** (proxy = label-prop, not paths) |
| Drift decomposition | `Δ_core=P_core Δ`, `Δ_periph=P_core^⊥ Δ` | — (descriptor + subtract) | **Design; primitives built** |
| Temporal filter | `created_at ≤ T < superseded_at` | `proxy` `build_communities(as_of)` :146–163 | Partial — **upper bound absent in proxy** |
| Reasoning compositions | induction/abduction/analogy/causal/planning | — | **Design** (operators built; compositions not) |
| Verifier tiers | grounding/consistency/formal/causal/predictive | — | **Design** (grounding = hand-enforced now) |

**Places the code does something the clean formula doesn't capture:**
1. **Two centering conventions** — C centers unit vectors by the unit-vector mean; proxy centers raw vectors by the raw mean. Same intent, non-identical numbers.
2. **Two covariance frames** — C computes the ellipsoid in full `ℝ^768` via dual-PCA; the proxy operators compute covariance/W₂/subtract in a global `K=24` PCA projection. The descriptor shape and the operator shape live in different spaces.
3. **Population vs sample variance** — radius/`total_variance` use `1/m`; axis extents use `1/(m−1)`. They are not mutually consistent by the Bessel factor.
4. **Overlap is not ellipsoid intersection** — it is member-Jaccard blended with normalized centroid proximity; the ellipsoid sphere is a render lens.
5. **Combine is pooled, not parametric** — it recomputes centroid/covariance from the union of raw points, which is the exact merged empirical covariance, not a weighted mean of the two Gaussians.
6. **Membership is overloaded** — attachment weight (C, max-over-sources), centered cosine distance (C), and min-max normalized cosine (proxy) are three different quantities that the prose calls "membership."
7. **Temporal filter is half the predicate in the proxy** — `created_at ≤ T` only; `superseded_at` upper bound lives in the store's `recall_at`, not the viz.
8. **Analogy, geodesic, drift-monitor, reasoning-compositions, verifier tiers are design** — specified precisely above but not present in `engram_geometry.c` or the proxy today.