Files

T

will.anderson 72fc6ffbf4 docs(engram): cognitive architecture design, prior-art scan, M10 reification, M8 perf profile, cutover-reversal runbooks, and 2026-08-12 session record

2026-08-13 00:22:29 -05:00

94 KiB

Raw Blame History

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:

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

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

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.
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.
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."
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:

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.
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).
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):

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

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.
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.
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.
Causal — intervention and counterfactual over the typed causal graph, as above.
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:

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.
Errors are meaning-neighbors, not noise: moon → sun, river → water, verb-love → noun-love — lands in the right neighborhood, slips within it.
Mean-centering helps (0.796 → 0.812) — a second independent confirmation of the embedding anisotropy the geometry corrects for (§21.1).
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:

Knowledge + memory → the engram graph (external, structured, editable, superseded with provenance) — the model stops carrying the world.
Reasoning + the operators → parameter-free linear algebra (a projection has zero params; overlap / subtract / route are computation over the geometry, not learned weights).
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.

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:

Grounding (anti-hallucination): admit(c) ⟺ support(c)=Σ_{n∈prov(c)} weight(n) ≥ τ_ground, else flagged speculation.
Consistency: reject if ∃ canonical k with contradicts(c,k) — geometric opposition (centroid cosine ≤ −τ), typed contradicts edge, or supersede-chain.
Formal: external solver verify(ℓ) = SOLVER(ℓ) ∈ {valid, invalid, unknown}; geometry proposes ℓ, solver disposes.
Causal: do(e)/counterfactual holds in the causal graph.
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:

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.
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.
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.
Overlap is not ellipsoid intersection — it is member-Jaccard blended with normalized centroid proximity; the ellipsoid sphere is a render lens.
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.
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."
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.
Analogy, geodesic, drift-monitor, reasoning-compositions, verifier tiers are design — specified precisely above but not present in engram_geometry.c or the proxy today.

94 KiB Raw Blame History Unescape Escape