core/docs/analysis/REALIZE-R1-DETERMINE-scope-2026-06-06.md

# REALIZE R1 + DETERMINE (Step 4) — scope, verified against the substrate

**Date:** 2026-06-06 · **Predecessor:** `REALIZE-scope-2026-06-06.md` (R0, #589/#590 merged at `16ba2771`).

This scopes the arc the goal names: R1 (relation-space recall, span-free
idempotency, the binding_graph/arithmetic realize path), the OOV-grounding
substrate question, and DETERMINE (Step 4). Every claim below was checked
against the merged `origin/main` source and, where noted, against an empirical
in-tree run (not a sandbox trace).

---

## 0. The unifying finding — the field versor is not an injective key for realized knowledge

R0 stored a realized fact as `(versor, metadata)` where
`versor = probe_ingest([subject_token]).F`. That conflates two distinct keys:

1. **Field placement** (the versor) — *associative*: "what is near this in
   concept space." Good for resonance, bad for identity.
2. **Structural identity** (`content_hash` / `structure_canonical` /
   `entity_names` / `relation_predicate`) — *exact, injective, reboot-stable by
   construction* (sha256 + canonical strings). This is what makes facts
   distinct and recallable-as-themselves.

The field versor collides on at least **three** axes (all verified):

- **Same subject, different relation.** "Truth is a concept." and "Truth is
  beautiful." both embed `probe_ingest(["truth"])` → the **same** versor. On
  recall both score `inf` (exact self-match) → indistinguishable. *(R0's
  acknowledged recall-collision.)*
- **Different OOV entities → one versor.** Empirically (in-tree, separate
  processes, `PYTHONHASHSEED` ∈ {0,1,random}): `zelophehad`,
  `photosynthesis`, `unbridgeable` — three unrelated words — all ground to the
  **byte-identical** versor (`ἀποκρίνομαι`'s root-versor). Root cause: the
  mounted morphology has **20 entries** (Greek/Hebrew cognition roots), so every
  arbitrary English token falls through `_best_decomposition`'s affinity
  fallback (`ingest/gate.py`) and collapses onto whichever root wins the tie.
- **(In-vocab is injective per-subject** but still collides per-relation, axis 1.)

**The fix that unifies R1-recall and OOV:** recall realized knowledge by its
**structural key** (exact metadata match), not solely by the field metric. The
field versor stays as deterministic associative placement. Structural recall is
**exact and deterministic** — it adds no cosine / HNSW / ANN, so it honors the
CLAUDE.md exact-recall invariant. `vault/store.py` is untouched (it stays a
forbidden-normalization site); structural recall is a read-only scan over
realized metadata, layered in `generate/realize/`.

## 1. OOV-grounding: the prior claim is refuted — it is deterministic, not non-deterministic

R0's recorded finding ("OOV grounding is NON-deterministic across reboots") is
**wrong** and is corrected here. Evidence (`/tmp/oov_proc.py`, faithful in-tree,
`no_load_state`):

- `probe_ingest([oov]).F` is **byte-identical across separate processes** and
  across `PYTHONHASHSEED` ∈ {0, 1, random}. In-vocab (`truth`) and OOV (`rhea`,
  `zelophehad`, …) are all deterministic.
- The latent hazard that *could* cause non-determinism — `_DECOMPOSITION_CACHE`
  keyed by `id(vocab)` (an `id()`-reuse-under-GC hazard) — is benign for
  identical-config runtimes (the cached value is a decomposition *string*; the
  versor is recomputed from the current vocab's roots, which are pack-identical).

So the real blocker for "accept arbitrary entities" is **non-injectivity**, not
non-determinism. And non-injectivity is **tolerable once recall is structural**:
distinct OOV facts stay distinct by `content_hash` even when they field-collide.
The honest, documented limit: *field-metric / associative recall* of OOV-named
facts is degenerate until the morphology substrate (or a content-addressed
entity identity) improves — but *structural* recall and reboot-stable storage
are exact today.

**Correction (from design-review): what actually carries reboot-stability.** The
versor placement is `probe_ingest([token])`, which `realize.py` itself documents
as composing with the *current session state* — so it is deterministic *given
the session state*, NOT a pure function of the subject, and NOT guaranteed to
re-derive identically in a fresh session at a different turn. Reboot-stability of
an already-realized fact rests on **Shape B+ snapshot** persisting the exact
versor *bytes* (`vault.to_dict`/`from_dict`, no reprojection on load), restored
bit-exactly — NOT on re-deriving the same versor. The cross-process determinism
finding above is a *bonus* (re-telling the same fact in a fresh, empty session
lands at the same place), not the load-bearing guarantee. Correctness of recall
rests on the **structural key**, not the versor, in every slice below.

## 2. The slices (dependency-ordered, each a small load-bearing PR; wrong=0 + versor_condition<1e-6 + exact recall preserved throughout)

### R1a — Structural recall (the keystone)

`generate/realize/recall.py::recall_realized(ctx, *, subject=None,
predicate=None, content_hash=None, structure_kind=None) -> tuple[RealizedRecord, ...]`.
A read-only, exact scan over `ctx.vault._metadata` entries with
`kind == "realized"`, matching the given structural predicates (subject ∈
`entity_names`, `relation_predicate ==`, `content_hash ==`, `structure_kind ==`),
returned in deterministic (vault-index) order. No metric, no vault mutation.

- **Falsifiable test:** realize two facts about "truth" with different
  predicates → `recall_realized(subject="truth")` returns **both** distinctly;
  `recall_realized(predicate=P1)` returns only the first. Assert that the raw
  `vault.recall(probe_ingest(["truth"]).F)` collides (both `inf`) — proving
  structural recall is *strictly necessary*, not decoration.

### R1b — Span-free idempotency

`content_hash = sha256_of(graph.to_canonical_string())` is **span-inclusive**
(`MeaningGraph.to_canonical_string()` emits `span={source_id}[start:end]` per
entity/relation — verified). So the same fact at a different offset does **not**
dedup. Add a span-free `structure_key` = sha256 of an ordered, span-free
projection: `(predicate, negated, tuple(argument-entity-names in arg order),
sorted other-entity-names)`. Dedup on `structure_key`; retain `content_hash`
(span-inclusive) for provenance.

- **Falsifiable test:** "Truth is a concept." at offset 0 and the same relation
  inside a longer carrier sentence (different span) → second realize returns
  `created=False`; vault length stays 1. A genuinely different fact (different
  predicate/args) is **not** collapsed.

### R1c — binding_graph / arithmetic realize

Extend `realize_comprehension` (or a sibling `realize_quantitative`) to accept a
`QuantComprehension` (`generate/quantitative_comprehension.py`):
`structure_kind = "binding_graph"`, `structure_canonical =
binding_graph.to_canonical_string()`, versor = deterministic placement
(`probe_ingest` of the asked/first entity token; OOV-safe per §1), recalled
**structurally**. Eligibility: a fact-bearing `QuantComprehension` (≥1
`BoundFact`); a pure query realizes nothing (it is recall, not intake), a
`Refusal` realizes nothing.

- **Falsifiable test:** `comprehend_quantitative("alice has 3 coins.")` →
  realize → `recall_realized(structure_kind="binding_graph", subject="alice")`
  returns the record; snapshot→reboot→recall is byte-exact; SPECULATIVE.

### OOV — lift the in-vocab gate (enabled by R1a)

Remove R0's `index_of` in-vocab gate; allow OOV subjects. Storage + structural
recall are exact and reboot-stable (§1). Add a cross-process determinism
guarantee test. Document the field-metric-collision limit in the record/docs
(honest, not papered over). Correct the refuted memory claim.

### D0 — DETERMINE (Step 4): reason over realized structure → assert / refuse

`generate/determine/determine.py::determine(question: Comprehension | Refusal,
ctx) -> Determined(answer, basis, predicate, grounds) | Undetermined(reason)`.
Take a *query-bearing* comprehension; structurally recall (R1a) the realized
facts that could ground it; run a **named entailment predicate** over the
realized structure — for R0/R1 relations, **direct structural entailment** (the
asked relation is exactly a realized relation; transitive subsumption is a later
extension). **Assert** the answer iff the asked relation is structurally
entailed by a realized fact; **refuse** (`Undetermined`) otherwise.

**Honesty correction (from design-review): as-told, never "verified".** Every
realizable record is **SPECULATIVE**, and `ADMISSIBLE_AS_EVIDENCE = {COHERENT}`
(teaching/epistemic.py) — so a realized record is admissible only as a
*candidate*, never as *evidence*. D0 therefore carries the grounding's epistemic
**basis** forward: a determination grounded in SPECULATIVE records is
`Determined(answer=…, basis="as_told", …)` — "based on what I was told
(unverified)" — and **never** a "verified" claim. COHERENT promotion is
out-of-scope, so D0 produces only `as_told` or `Undetermined` (honest and
non-vacuous). No estimation. No corpus mutation (teaching stays HITL
proposal-only). wrong=0: never assert an un-entailed claim, never upgrade
SPECULATIVE to verified.

- **Falsifiable tests (must bite):** realize "Truth is a concept."; ask "Is
  Truth a concept?" → `Determined(answer=True, basis="as_told", predicate=
  "member", grounds=[that record])`. **Present-but-non-entailing:** ask "Is
  Truth a number?" (a record about *truth* exists, but `member(truth, number)`
  is NOT realized) → `Undetermined("not_entailed")`. Ask before realizing →
  `Undetermined("ungrounded")`. A `Refusal` question → `Undetermined`. **Mutation
  check:** delete the grounding record → `Determined` flips to `Undetermined`
  (proves the verdict is entailment, not "a record about the subject exists").

## 3. Sequencing, hazards, invariants

Order: **R1a → R1b → R1c → OOV → D0** (R1a unblocks recall for R1c/OOV/D0; R1b is
independent/small). Each slice:

- preserves **wrong=0** (every ineligible/ungrounded input realizes/determines
  NOTHING — typed `NotRealized` / `Undetermined`, never a coerced write/assert);
- preserves **versor_condition < 1e-6** (no new embedder; `probe_ingest` only,
  closure stays `algebra/versor.py`'s);
- preserves **exact CGA recall** (structural recall is exact metadata match, not
  a metric approximation; `vault/store.py` untouched);
- keeps **EpistemicStatus honesty** (SPECULATIVE only; COHERENT is never a
  default — promotion stays out of scope, a later slice);
- adds no **parallel learning path** (DETERMINE asserts/refuses; it does not
  ratify or mutate corpus — teaching stays HITL proposal-only);
- holds **INV-21** (only allowlisted writers call `VaultStore.store`; R1c's
  writer is allowlisted) and does not regress the capability-index anchor
  (breadth 8, wrong 0, `50e0675b`).

## 3.5 Verified adjustments (adversarial design-review, 2026-06-06)

Six skeptic agents tried to refute each slice against the merged source +
CLAUDE.md. All six returned **adjust** (none blocked, none rubber-stamped).
Resolutions, each re-grounded in source:

- **R1a — public accessor, not `_metadata`.** `realize.py` is the *only*
  external reader of the private `vault._metadata` (the R0 "established pattern"
  comment is false). → Add a read-only `VaultStore.iter_metadata()` yielding
  `(index, metadata)` in deque order (non-mutating, not a normalization site);
  `recall_realized` and the R0 dedup loop consume it; delete the false comment.
  `vault_index` is the **live** deque position (authoritative in the unbounded
  session tier; provenance-only under bounded eviction — pinned, not left
  ambiguous). *Invariant risk: none — exact metadata equality is the opposite of
  approximate recall.*
- **R1b — entity *identity*, plus a wrong=0 refusal.** `Entity.name` is
  non-unique in the model (only `entity_id` is enforced unique; today the reader
  sets `entity_id == name`, reader.py:364, so the hazard is latent, not live).
  A name-keyed `structure_key` could collapse a converse/homonym fact →
  drops a distinct fact (wrong=0). → `structure_key` keys on the ordered
  argument **entity-ids** (`== name` today, span-free), AND realize **refuses**
  a graph with duplicate entity names: `NotRealized("ambiguous_entity_names")`
  — the defense-in-depth guard CLAUDE.md asks for *now*, before a future reader
  makes it live.
- **R1c — honest versor, real guard.** The versor rule is restated per §1
  (deterministic-given-session-state; the sumquery `"total"` is a synthesized
  OOV name with maximal collision — documented like §0, since **structural
  recall carries correctness**). The "fact-bearing" gate is vacuous at the
  realize layer (every `QuantComprehension` has ≥1 fact + one query by
  construction); the real wrong=0 filter is `isinstance(comp, Refusal) →
  NotRealized` (and `comprehend_quantitative` already refuses factless input
  upstream). *No wrong=0 admission breach: every equation passed
  `check_admissibility`; a `Refusal` short-circuits.*
- **OOV — correct the side-effect contract.** `probe_ingest` of an OOV subject
  is **not** side-effect-free: it mutates the shared vocab via
  `insert_transient` (gate.py:252). → Correct realize.py's "side-effect-free"
  comment; document the transient as session-scoped, **excluded from the
  snapshot** (snapshot serializes vault+state, *not* vocab — verified
  session/context.py:345), and re-derived on reboot. The determinism test bites
  on two axes: cross-process byte-identity AND intra-session path-independence
  (probe equals cold-reground whether or not grounded earlier). *Invariant risk:
  none — a non-versor construction raises and is caught → `NotRealized`.*
- **D0 — as-told, never verified** (see the corrected design above).
- **Cross-cutting — anchor partition proven.** The capability-index eval imports
  **no** `vault` / `ChatRuntime` / `realize` / `SessionContext` / `probe_ingest`
  (grep of `evals/capability_index/` is empty) — it scores comprehension against
  oracles and never realizes or recalls from a session vault. So realize-writes
  **cannot** regress the anchor (50e0675b) — partition by construction, not
  assertion. Runtime metric-recall pollution (OOV facts clustering at the
  root-versor) is a separate, bounded note: realized entries are SPECULATIVE +
  `kind`-tagged, so the evidence path (`min_status=COHERENT`) already excludes
  them; default (candidate) recall includes them as the session's own memory by
  design. Sequencing R1a→R1b→R1c→OOV→D0 is confirmed sound.

## 4. Explicitly out of scope (later)

COHERENT promotion (contradiction-free coherence judgment), teaching-loop
proposal generation from realized facts, trace-folding, content-addressed
entity identity / morphology-substrate expansion (the deeper OOV-injectivity
fix), LEARNED ESTIMATION (Step 6), the always-on process (L10).