diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 451c19c65..4e92d4540 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,141 @@ +## 2026-08-23 — E-STREAM-ORDER-VS-PREFIX-TREE-NEITHER-ACCUMULATES-1 — the two closest shipped candidates for the belief tree-overlay delegation are different topologies, and NEITHER implements an accumulate-fold + +**Status:** FINDING (grounds and sharpens the `BELIEF-ABI-RESTORATION-1` +Step 1 audit's [ABSENT] verdict on the tree-overlay delegation mechanism; +does not overturn it). **⚠ PARTIALLY REGRADED 2026-08-23 — see the note +immediately below.** +**Confidence:** High for the [ABSENT] verdicts (the entry's actual result). +**Lowered for the "different topologies" FRAMING**, which overstated an +opposition. + +> **⊘ REGRADE (2026-08-23, `E-HIERARCHY-IS-THE-ADDRESS-SPACE-NOT-THE- +> ONTOLOGY-1`).** This entry framed candidate A (stream order over time) +> and candidate B (prefix tree over address) as an *opposition* — "a total +> order over TIME, a partial order over ADDRESS," presented as if a datum +> had to live in one universe or the other. **That framing is too strong.** +> Under the address-space law, hierarchy is the ADDRESS SPACE, not the +> ontology: a temporal datum is not a separate non-HHTL universe, it can be +> HHTL-addressed (`episode → version window → event region → event +> identity`) with the signed ±i4 offsets as LOCAL traversal *inside* an +> addressed neighborhood. Stream ordering remains temporal semantics; HHTL +> supplies its home. The two are **layered, not rival**, and no "separate +> temporal universe" needs to exist. +> +> **What survives the regrade unchanged — the entry's actual finding:** +> neither candidate implements a children-and-siblings accumulate fold +> (`fn accumulate` / `children.*sibling`: zero hits; +> `E-NO-BUNDLE-STANDING-WAVE-1` disclaims accumulation by name). Both +> [ABSENT] verdicts stand. Also unchanged: the withdrawal of the +> composition conclusion, and the fence against rebasing a version-ordered +> type to mean an address span — that fence is *strengthened* here, because +> the right move was never to re-scope `VersionRange` but to give the +> temporal datum its own address and leave time as time. + +**The question that prompted this.** Step 1 of `BELIEF-ABI-RESTORATION-1` +found that `Belief.rung`/`stamp`'s operator-ruled delegation — "rung = HHTL +tree depth, stamp = children-and-siblings accumulation, inherit from +parent" — names a mechanism that is currently prose and precedent, not +code (`.claude/plans/belief-abi-restoration-v1.md` §Step 1: zero +`FacetCascade`/`facet_classid` occurrences in `nars/`, zero `fn accumulate` +or `children.*sibling` hits in `lance-graph-contract/src/`). A follow-up +asked directly: is the "24×i4 Markov left-right-corner parsing" the +missing mechanism, compared against "AriGraph-style HHTL basins"? Grounding +both candidates in shipped code answers: **they are not rival +implementations of the same job — one is a total order over TIME, the +other a partial order over ADDRESS — and neither one accumulates.** + +**Candidate A — `deepnsm-v2::wave::WitnessStream` (the G24N4/Markov +reading).** `wave.rs` module doc, verbatim: *"Each versioned event owns its +`CausalWitnessFacet` loci; the wave **reads** a version-range window and +mutates nothing — there is no accumulator and no shared register. The +Markov property is STREAM ORDER (`E-MARKOV-TEMPORAL-STREAM-1`), never a +superposition into one carrier."* Concretely: `events: Vec<(u64, +CausalWitnessFacet)>` in append order; `ground_at`/`resolve_at` walk a +SIGNED OFFSET through that flat line within a version-visibility window +(`TemporalPov::at`). This is where left-corner parsing theory actually +enters the codebase — but only as a CITATION justifying the ±8 nibble +range (Manning & Carpenter 1997, IWPT-97 Table 7: max left-corner stack +depth over the whole binarized WSJ treebank is 8), never as an executing +parser. There is no tree here. `E-NO-BUNDLE-STANDING-WAVE-1` is a standing +refusal to accumulate, not an oversight. + +**Candidate B — `AttentionFocusFacet` (the AriGraph/HHTL-basin reading).** +`covers`/`common_prefix` (`attention_facet.rs:297,314`) give coarse→fine +PREFIX containment over the same 12-byte cascade — ancestor/descendant by +shared byte prefix, ordinal position, never stream position. +`common_prefix` computes the meet (deepest common ancestor) two focuses +share, which IS the shape a "rung = tree depth" claim would need to walk. +But nothing here sums, folds, or aggregates evidence across a node's +children into a parent value — `covers`/`common_prefix` answer "is A an +ancestor of B" / "what do A and B share", never "what do B's children +contribute to A". Grepped independently for this pass: zero `fn +accumulate` hits and zero `children.*sibling` hits anywhere under +`lance-graph-contract/src/attention_facet.rs`, `facet.rs`, or `hhtl.rs`. + +**A third, previously-conflated shipped thing, named so it stops being +confused with either candidate:** `insight_right_corner_read.rs` +(`lance-graph-planner/examples/`) is a REAL left-corner/right-corner SVO +clause parser running on real KJV text — but it is a `Basins`-driven token +scan with its own `RightCornerReason`/`Triple` types and touches +`CausalWitnessFacet`/G24N4 **not at all**. "Left-corner parsing" and +"G24N4" are two unconnected machines in this codebase; only `wave.rs`'s +module-doc citation bridges them, and only as a numeric-range +justification, not a shared mechanism. + +(A fourth precedent worth naming for completeness, since it was checked in +the same pass and is the closest thing to a REAL KJV+G24N4 example: +`probe_binding_not_heuristic.rs` resolves `Locus::Antecedent` — a single +locus, single-hop structural anaphora binding — on Gen 3:1/3:7. It proves +the chip is load-bearing, not decorative. It is not an accumulate-fold +either: it is a pointer write/read on one register, the same shape +`wave.rs`'s single-owner events already generalize.) + +**The consequence — and the inference NOT to draw.** The finding is +negative and stops there: + +``` + A is not the mechanism + B is not the mechanism + ⇒ WE DO NOT HAVE THE MECHANISM +``` + +**⇒ NOT `therefore A × B is the mechanism`.** An earlier revision of this +entry concluded that Step 3 must COMPOSE the two (a stream-order walk +bound to a tree address). **That leap is withdrawn.** "Neither of the two +things I checked is it" licenses no claim whatever about what it is; the +composition is one hypothesis among unknown others, and elevating it to +"what Step 3 must build" would smuggle a design decision in through a +negative result. + +**The specific danger that withdrawal avoids, recorded as a fence.** The +withdrawn composition proposed rebasing `WitnessStream` from VERSION +order into "address-scoped stream order," possibly repurposing +`VersionRange`. That is precisely the semantic type drift this +architecture exists to prevent: **time is time, address is address.** +Sharing a memory ABI does not make two topologies interchangeable, and a +`VersionRange` that sometimes means an address span is a type whose +meaning depends on who is holding it. Further: any future address-scoped +fold must be a BORROWED VIEW over ABI-resident rows — if it materializes +another `Vec<(u64, CausalWitnessFacet)>`, the memory escape has simply +re-entered through a different door (`E-TYPE-COMPLEXITY-EXPOSED-A-MEMORY- +ABI-ESCAPE-1`), and `wave.rs`'s own honesty note already records that +`WitnessStream` is TODAY *"a parallel OWNED container beside +`TemporalStream`, not a zero-copy projection."* + +**Two inherited assumptions this entry does not carry forward.** Neither +is established, and the negative finding does not support either: (a) +`rung = HHTL tree depth` — the answerable question is whether derivation +depth is reconstructible from SUPPORT topology, which needs no address at +all; (b) `stamp = commutative accumulation` — any replacement must +reproduce `Stamp`'s load-bearing IDENTITY semantics (disjointness, +overlap, source-set union, no double-count, `belief.rs:39-48`), and a +`vsa_bundle`-style fold is not automatically a source-set union. + +**Bounds respected:** no code changed by this finding; no tenant minted; +no mechanism proposed; no canonizing on either candidate. The open +questions this finding leaves are registered — explicitly as questions, +not a plan — in `.claude/plans/tarski-markov-hhtl-seam-v1.md`. + ## 2026-08-23 — E-TYPE-COMPLEXITY-EXPOSED-A-MEMORY-ABI-ESCAPE-1 — the clippy warning was the surface symptom; `BeliefArena` is an independent AoS cognitive population owner outside the canonical memory ABI **Status:** FINDING (operator-escalated; #1004 recut to a discovery receipt). diff --git a/.claude/board/INTEGRATION_PLANS.md b/.claude/board/INTEGRATION_PLANS.md index f4db6516f..d87b0dfa6 100644 --- a/.claude/board/INTEGRATION_PLANS.md +++ b/.claude/board/INTEGRATION_PLANS.md @@ -1,3 +1,34 @@ +## 2026-08-23 — TARSKI-MARKOV-HHTL (open-questions register — HELD, not a plan) + +`.claude/plans/tarski-markov-hhtl-seam-v1.md` — **holds open questions; +proposes no mechanism and licenses no work.** Motivated by +`.claude/board/EPIPHANIES.md` +`E-STREAM-ORDER-VS-PREFIX-TREE-NEITHER-ACCUMULATES-1`: the operator-ruled +tree-overlay delegation for `Belief.rung`/`stamp` has NO shipped +implementation, and its two closest candidates both fall short in +different ways — `deepnsm-v2::wave::WitnessStream` is a stream-order +(total-order-over-time) reading that disclaims accumulation by name +(`E-NO-BUNDLE-STANDING-WAVE-1`); `AttentionFocusFacet` is a prefix-tree +(partial-order-over-address) containment reading with no fold operator. + +**A first revision of this entry said Step 3 "must COMPOSE" the two. That +is withdrawn.** From *A is not it* and *B is not it* the only conclusion +is *we do not have it* — never *A × B is it*. The withdrawn composition +also proposed rebasing a version-ordered stream into "address-scoped" +order, which is exactly the semantic type drift the DOCK/ROUTE separation +exists to prevent (time is time; address is address), and risked +re-entering the memory escape through a newly materialized owned `Vec`. + +What the file now carries: open questions Q1–Q5 (is depth reconstructible +from SUPPORT topology at all — needing no address; what must a `Stamp` +replacement preserve, given its identity semantics are disjointness / +overlap / source-set union / no-double-count, which a generic commutative +fold does not supply; can a `Belief` acquire an identity-derived address; +is route provenance load-bearing; **is there a mechanism neither candidate +resembles**), plus standing fences that bind any future answer. Nothing +here is startable; the next legitimate step is `BELIEF-ABI-RESTORATION-1` +Step 2. + ## 2026-08-21 — D-ACR-7 BAND-READING CONTRACT (council-ratified spec) `.claude/plans/dacr7-band-reading-contract-v1.md` — the 59..63 reading diff --git a/.claude/plans/tarski-markov-hhtl-seam-v1.md b/.claude/plans/tarski-markov-hhtl-seam-v1.md new file mode 100644 index 000000000..1af89b8d5 --- /dev/null +++ b/.claude/plans/tarski-markov-hhtl-seam-v1.md @@ -0,0 +1,122 @@ +# TARSKI-MARKOV-HHTL — open questions register (NOT a plan) + +> Status: **HELD — OPEN QUESTIONS ONLY. This file proposes no mechanism and +> licenses no work.** An earlier revision was a design plan for a specific +> composition (a stream-order reading bound to a tree address); that +> proposal is **withdrawn** — see § The withdrawn proposal. What remains is +> the register of what is genuinely unknown after +> `E-STREAM-ORDER-VS-PREFIX-TREE-NEITHER-ACCUMULATES-1`, so a future +> session inherits the questions without inheriting an unearned answer. + +## What is established + +`BELIEF-ABI-RESTORATION-1`'s Step 1 audit found the operator-ruled +tree-overlay delegation for `Belief.rung`/`stamp` has no implementing code. +The follow-up finding (`.claude/board/EPIPHANIES.md`, +`E-STREAM-ORDER-VS-PREFIX-TREE-NEITHER-ACCUMULATES-1`) checked the two +closest shipped candidates and found neither is the mechanism: + +``` + deepnsm-v2::wave::WitnessStream a TOTAL ORDER over time + flat Vec<(version, register)>, signed-offset walk in a version window + disclaims accumulation BY NAME (E-NO-BUNDLE-STANDING-WAVE-1) + + AttentionFocusFacet a PARTIAL ORDER over address + covers / common_prefix — prefix containment, the meet + answers "is A an ancestor of B", never "what do B's children give A" +``` + +That is the whole result. It is negative. + +## The withdrawn proposal (recorded so it is not re-derived) + +This file previously concluded that since neither candidate is the +mechanism, Step 3 must **compose** them — a `WitnessStream`-shaped window +rebased from version order into "address-scoped stream order," feeding an +accumulate operator. **Withdrawn**, for three reasons: + +1. **The inference is invalid.** From *A is not it* and *B is not it*, the + only conclusion is *we do not have it* — not *A × B is it*. The + composition is one hypothesis among unknown others; a negative result + cannot promote it. +2. **It proposed semantic type drift.** Rebasing a `VersionRange` (or a + version-ordered stream) to mean an address span makes a type whose + meaning depends on who holds it. **Time is time. Address is address.** + Sharing a memory ABI does not make two topologies interchangeable — + preventing exactly this is why the DOCK/ROUTE separation is written the + way it is. +3. **It risked re-entering the memory escape.** A "`WitnessStream`-shaped + window" that materializes another `Vec<(u64, CausalWitnessFacet)>` is + the escape through a different door. `wave.rs`'s own honesty note + already records that `WitnessStream` is TODAY *"a parallel OWNED + container beside `TemporalStream`, not a zero-copy projection over the + real `ValueTenant::CausalWitness` lane."* + +## Regrade (2026-08-23) — the opposition was overstated + +`E-HIERARCHY-IS-THE-ADDRESS-SPACE-NOT-THE-ONTOLOGY-1` weakens the framing +above. The two candidates are **layered, not rival**: a temporal datum can +be HHTL-addressed (`episode → version window → event region → event +identity`) with the signed ±i4 offsets as LOCAL traversal inside that +addressed neighborhood. Time stays time; HHTL supplies the home. There is +no "separate temporal universe" to reconcile. + +This does NOT revive the withdrawn composition — it removes the motivation +for it. The withdrawn proposal wanted to re-scope a version-ordered type to +mean an address span; the address-space law says the correct move was +always to give the temporal datum its own address and leave the ordering +alone. The fence in § The withdrawn proposal is therefore *strengthened*, +not relaxed. + +What survives unchanged: neither candidate implements a children-and- +siblings accumulate fold, which was and remains this register's reason to +exist. + +## The open questions (each stated as a question, none as a direction) + +- **Q1** — Is derivation depth reconstructible from SUPPORT topology (the + premise DAG) alone? This is answerable with no address at all, and is + the question `rung = HHTL tree depth` should have been. + *Partial evidence:* `PROBE-TARSKI-SIGNED-WITNESS-1` gate A2 (PR #1007) + derived depth from the premise DAG alone and it reproduced the arena's + stored `rung` 10/10 — **on one fixture, of one shape**. That is a + measurement, not a general result, and it says nothing about HHTL depth. +- **Q2** — What would a replacement for `Stamp` have to preserve? Not "a + commutative fold": `Stamp`'s load-bearing behaviour is IDENTITY + semantics — disjointness detection, overlap detection, source-set union, + no-double-count (`belief.rs:39-48`), plus the documented modulo-64 + folding that is conservative BY DESIGN ("folding can only create false + overlap, never false disjointness"). A `vsa_bundle` or any generic + commutative accumulate is not automatically a source-set union and must + not be assumed equivalent. +- **Q3** — Can a `Belief` acquire a canonical address at all — one derived + from node/relation IDENTITY rather than from arena position? Step 1's + recut records why a position-derived address is not an answer: it turns + a `Vec` index into a pretty 16-byte `Vec` index. +- **Q4** — Do two proof routes with tied truth carry different provenance? + `PROBE-TARSKI-SIGNED-WITNESS-1` observed that `close_transitive`'s + `HashMap` iteration order makes both premise indices AND tie-broken + derivation routes vary across identical builds. Whether that is a + reproducibility defect or an acceptable degree of freedom depends on + whether route identity is ever load-bearing — unresolved. +- **Q5** — Is there a mechanism neither candidate resembles? Unasked so + far, and the most likely place a real answer lives, precisely because + nobody has looked there. + +## Standing fences (apply to any future answer, whatever it turns out to be) + +- A time-ordered type must not be re-scoped to mean an address span. +- Any address-scoped read must be a BORROWED VIEW over ABI-resident rows, + never a new owned container. +- A new reading of shared geometry gets its OWN ClassView and its OWN + vocabulary; it may not use another ClassView's semantic API to mean + something that ClassView forbids (the A9 "loci, not magnitudes" lesson, + `PROBE-TARSKI-SIGNED-WITNESS-1` recut). +- Anti-vacuity: a fold that reproduces `max(premise rungs)+1` regardless of + tree shape has proven nothing (this repo's own falsifiability rule). + +## Trigger + +Nothing here is startable. The next legitimate step is +`BELIEF-ABI-RESTORATION-1` Step 2 — the operator ruling on the Step 1 +residue — which may or may not make any of Q1–Q5 relevant.