From 2244de7be1e4790208007401d51512a0fb0e2c1b Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 23 Aug 2026 18:06:38 +0000 Subject: [PATCH 1/3] epiphany: stream-order Markov vs prefix-tree HHTL, neither accumulates E-STREAM-ORDER-VS-PREFIX-TREE-NEITHER-ACCUMULATES-1 (EPIPHANIES.md): grounds and sharpens BELIEF-ABI-RESTORATION-1's Step 1 [ABSENT] verdict on the tree-overlay delegation mechanism by naming and checking the two closest shipped candidates in code: - deepnsm-v2::wave::WitnessStream (the G24N4/Markov reading) is a flat, version-ordered stream. Its own module doc disclaims accumulation by name (E-NO-BUNDLE-STANDING-WAVE-1: "there is no accumulator and no shared register"). Left-corner parsing theory enters only as a citation justifying the +-8 nibble range (Manning & Carpenter 1997), never as an executing parser -- and insight_right_corner_read.rs (the actual left-corner/right-corner SVO parser on KJV text) touches CausalWitnessFacet/G24N4 not at all. These are two unconnected machines, not one. - AttentionFocusFacet (the AriGraph/HHTL-basin reading) gives coarse-to-fine PREFIX containment (covers/common_prefix) -- ancestor/ descendant by shared byte prefix. It answers "is A an ancestor of B", never "what do B's children contribute to A". Zero fn accumulate / children.*sibling hits confirmed under lance-graph-contract/src/. Consequence for the ladder: a Step 3 probe cannot restate either candidate as the fold -- it must COMPOSE a stream-order reading bound to a specific tree address, which is an undesigned seam. .claude/plans/tarski-markov-hhtl-seam-v1.md: the deferred integration plan for that seam. Sketches the composition (HHTL address -> per- address windowed stream -> accumulate operator -> rung/stamp as a projection, never a stored field), names the open design questions (is the window WitnessStream re-scoped or new; what is the fold; read- time query vs materialized; does this fold WITH or REPLACE the already-proven G24N4 signed-witness reading from PROBE-TARSKI-SIGNED- WITNESS-1), lists what's already reusable (both #1007 probes), and pre-registers falsifiers SF1-SF5 (parity vs current rung, anti-vacuity on a non-trivial tree shape, commutative accumulation per I-SUBSTRATE-MARKOV, no cross-plane retroactive rewrite, honest-failure reporting). Explicitly gated: do not start until BELIEF-ABI-RESTORATION-1 Step 2 (the operator ruling on the Step 1 residue) lands -- this plan is input to that ruling, not a substitute. INTEGRATION_PLANS.md: same-commit board hygiene PREPEND entry per this repo's own mandatory rule. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01KCGhDYoQBXs3poaR7sFuqp --- .claude/board/EPIPHANIES.md | 83 +++++++++++ .claude/board/INTEGRATION_PLANS.md | 20 +++ .claude/plans/tarski-markov-hhtl-seam-v1.md | 144 ++++++++++++++++++++ 3 files changed, 247 insertions(+) create mode 100644 .claude/plans/tarski-markov-hhtl-seam-v1.md diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 451c19c65..2beb6fe50 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,86 @@ +## 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). +**Confidence:** High — every claim below is grep- and read-verified against +shipped code, not inferred from module-doc prose alone. + +**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, stated precisely so Step 3 doesn't restate either +candidate by mistake.** If the operator's ruling is to be built rather +than merely re-asserted, Step 3's probe cannot pick ONE of these two +shipped mechanisms and call it done — neither is the fold. It would need +to COMPOSE them: a stream-order Markov reading (candidate A's window/ +offset walk) BOUND to a specific tree address (candidate B's prefix +containment, so "depth" and "which subtree" are meaningful at all) — +which is itself a new, undocumented seam, not a restatement of anything +shipped. Flagged as a future integration item, not built here (Step 1's +own scope: audit-first, no layout invented). + +**Bounds respected:** no code changed by this finding; no tenant minted; +no canonizing on either candidate as sufficient. See +`.claude/plans/tarski-markov-hhtl-seam-v1.md` for the deferred integration +plan this finding motivates. + ## 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..3f8033083 100644 --- a/.claude/board/INTEGRATION_PLANS.md +++ b/.claude/board/INTEGRATION_PLANS.md @@ -1,3 +1,23 @@ +## 2026-08-23 — TARSKI-MARKOV-HHTL-SEAM-1 (deferred, gated on BELIEF-ABI-RESTORATION-1 Step 2) + +`.claude/plans/tarski-markov-hhtl-seam-v1.md` — names the seam a future +`BELIEF-ABI-RESTORATION-1` Step 3 must build, 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` (HHTL depth + accumulate +from children/siblings) has NO shipped implementation, and its two closest +candidates are different topologies that both explicitly fall short — +`deepnsm-v2::wave::WitnessStream` is a stream-order Markov reading that +disclaims accumulation by name (`E-NO-BUNDLE-STANDING-WAVE-1`); +`AttentionFocusFacet` is a prefix-tree containment reading (`covers`/ +`common_prefix`) with no fold operator. Step 3 must COMPOSE a stream-order +reading bound to a tree address, not restate either. Falsifiers SF1-SF5 +pre-registered; PROBE-TARSKI-SIGNED-WITNESS-1 and +PROBE-FOUR-PLANE-CAUSAL-MEDIUM-1 (both #1007) are named as reusable, +already-proven inputs. **Explicitly deferred** — do not start until +`BELIEF-ABI-RESTORATION-1` Step 2 (operator ruling on the Step 1 residue) +lands; this plan is input to that ruling, not a substitute. + ## 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..c0bc16edd --- /dev/null +++ b/.claude/plans/tarski-markov-hhtl-seam-v1.md @@ -0,0 +1,144 @@ +# TARSKI-MARKOV-HHTL-SEAM-1 — a stream-order reading bound to a tree address + +> Status: DEFERRED INTEGRATION ITEM. Named, not built. Gated on +> `BELIEF-ABI-RESTORATION-1` Step 2 (operator ruling on the Step 1 residue) +> landing first — this plan is the eventual Step 3 probe's design surface, +> not a replacement for it. + +## The gap this plan names + +`BELIEF-ABI-RESTORATION-1`'s Step 1 audit (`.claude/plans/belief-abi-restoration-v1.md`, +merged in #1006) found that the operator-ruled delegation for +`Belief.rung`/`stamp` — *"rung = HHTL tree depth, stamp = accumulate from +children and siblings, inherit from parent"* — names a mechanism that does +not exist in code. A follow-up asked whether either of the two closest +shipped candidates already IS that mechanism. Grounding both +(`.claude/board/EPIPHANIES.md`, +`E-STREAM-ORDER-VS-PREFIX-TREE-NEITHER-ACCUMULATES-1`) found: no. + +``` + Candidate A: deepnsm-v2::wave::WitnessStream (G24N4 / Markov) + events: Vec<(u64, CausalWitnessFacet)> — flat, append-ordered + ground_at / resolve_at: signed-offset walk within a VERSION window + explicit refusal to accumulate (E-NO-BUNDLE-STANDING-WAVE-1): + "there is no accumulator and no shared register" + → a TOTAL ORDER over time. No tree. + + Candidate B: AttentionFocusFacet (AriGraph / HHTL basins) + covers / common_prefix — coarse→fine PREFIX containment + answers "is A an ancestor of B" / "what do A, B share" + never "what do B's children contribute to A" + → a PARTIAL ORDER over address. No fold. +``` + +Neither candidate accumulates. The operator's ruling therefore describes a +mechanism that must be BUILT by composing the two, not selected from +what already exists. + +## The seam (sketched, not designed) + +``` + HHTL address (Candidate B) + │ gives: which subtree, what "depth" means, ancestor/descendant + ▼ + a per-address WitnessStream-shaped window (Candidate A's machinery, + rebased from "version order" to "address-scoped stream order" — + the events visible to a fold are the ones IN that subtree, ordered + however the fold needs, not necessarily by version) + │ gives: a bounded, single-owner sequence to walk/reduce + ▼ + an accumulate operator over that sequence + (children's registers → parent's register; NOT `MergeMode::Xor`, + per I-SUBSTRATE-MARKOV — magnitude-side accumulation is `vsa_bundle` + or an equivalent commutative fold, never raw XOR) + │ + ▼ + Belief.rung / Belief.stamp AS A PROJECTION of the folded result, + never a separately-stored field +``` + +Every arrow above is a genuine design decision, not a restatement: + +1. **Is the per-address window literally `WitnessStream` re-scoped, or a + new type?** `WitnessStream::window_range` already takes an arbitrary + `VersionRange` — whether an "address range" (an HHTL subtree) can be + expressed as a re-purposed version-like ordering, or needs its own + window abstraction, is open. +2. **What is the fold?** `carried_awareness`, the Horner sum in + `rail_geometry.rs:183`, and `causal_audit`'s append-only history were + each checked in Step 1 and shown to be a DIFFERENT mechanism from + "children+siblings accumulate, inherit from parent" — none is a + template to copy. The fold itself is undesigned. +3. **Does `rung` become a read-time query over the fold, or does the fold + get materialized per address?** The zero-copy-warden's law ("zero + copy is a law without escape hatches... the array itself is a + ClassView projection") argues for read-time; but a fold that walks an + unbounded subtree on every read is a real cost question, not yet + measured. +4. **Does this replace `BeliefArena.rung: u32` entirely, or does `rung` + become `support_ceiling()` over a resident G24N4 register as + `PROBE-TARSKI-SIGNED-WITNESS-1` already demonstrates (PR #1007), with + the HHTL-address binding as a SEPARATE, later-composed axis?** These + are not obviously the same migration. The Tarski-signed-witness probe + proved the SIGN/MAGNITUDE reading works over a resident register with + no address at all (a flat `Dock` array, no `FacetCascade` address + minted per belief). Binding that register to a real HHTL address is + an ADDITIONAL step this plan is scoping, not one already done. + +## What is already proven and can be reused as-is + +- `PROBE-TARSKI-SIGNED-WITNESS-1` (PR #1007): the G24N4 signed reading + (`SupportedBy`/`Contradiction` as depth, not magnitude) reproduces + `Belief::rung` exactly on the positive lane, and retains what the + shipped `admit_derived` CHOICE law provably discards. This is the + EVIDENCE-content half of the eventual fold's input — settled, reusable. +- `PROBE-FOUR-PLANE-CAUSAL-MEDIUM-1` (PR #1007): proves the four-plane + separation (WHERE / WHAT / WHICH-LENS / WHY) composes over disjoint + lanes of one resident row without any plane auto-deriving another. This + is the discipline the eventual fold must respect: an accumulate + operation over the WHY plane must not silently rewrite the WHAT/WHICH + planes, exactly as `PROBE-FOUR-PLANE-CAUSAL-MEDIUM-1`'s FP3 already + requires for a single row. +- The A9 "loci, not magnitudes" law and the DOCK/ROUTE separation + (`E-TYPE-COMPLEXITY-EXPOSED-A-MEMORY-ABI-ESCAPE-1`) bound the shape any + new reading must take: classid chooses the reading, the route chooses + the traversal, the bytes never change shape. + +## What this plan does NOT do + +- Does not mint a tenant, a classid, or a `CascadeShape` variant. +- Does not implement the fold. This is a design surface, not a probe. +- Does not resolve open questions 1-4 above — they are the actual content + of a future Step 3, and should be answered by a probe with pre-registered + falsifiers (per this repo's own standing falsifiability rule: "a guard + that fires on everything carries exactly as much information as one + that never fires" — an accumulate-fold that always reproduces + `max(premise rungs)+1` regardless of tree shape has proven nothing). + +## Falsifiers a Step-3 probe against this seam must clear + +- **SF1** — the fold, bound to a real per-belief HHTL address, reproduces + `BeliefArena`'s CURRENT `rung = max(premise rungs)+1` on the positive-only + corpus (parity oracle, same shape as `PROBE-TARSKI-SIGNED-WITNESS-1`'s + A1/A2 gates). +- **SF2** — the fold survives a NON-trivial tree shape (siblings with + different depths, a node with zero children) without collapsing to a + constant — the anti-vacuity discipline this repo's `CLAUDE.md` + ("the falsifiability rule") already mandates for any new guard/fold. +- **SF3** — accumulation uses a commutative operator (`vsa_bundle` or + equivalent), never raw XOR on the magnitude side, per + `I-SUBSTRATE-MARKOV`. +- **SF4** — binding an address to a belief does not retroactively change + any OTHER plane of that belief's row (FP3's discipline, generalized). +- **SF5** — if SF1-SF4 cannot all be cleared, the probe reports the EXACT + missing bit/field/route invariant (per the charter's own instruction: + "report the exact falsifier if it cannot reproduce the arena's current + rung/stamp results. Do not force it.") rather than silently degrading + the parity requirement. + +## Trigger to promote this from "named" to "active" + +Do not start this until `BELIEF-ABI-RESTORATION-1` Step 2 (the operator +ruling on the Step 1 residue table — `premises`, `stmt`/`truth`, and this +tree-overlay mechanism, itemized) has landed. This plan is input to that +ruling, not a substitute for it. From 87a576f0e7a93b1e4c8a8972ae3d8667cb31993e Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 23 Aug 2026 18:26:16 +0000 Subject: [PATCH 2/3] recut: keep the negative finding, withdraw the composition seam Addresses the review of #1008. The epiphany's negative result stands; the positive conclusion drawn from it did not. 1. WITHDRAWN: "neither accumulates, therefore Step 3 must COMPOSE them." From `A is not it` and `B is not it` the only valid conclusion is `we do not have it` -- never `therefore A x B is it`. The composition was one hypothesis among unknown others, and promoting it to "what Step 3 must build" smuggled a design decision in through a negative result. Recorded as withdrawn in place, not deleted. 2. The specific danger that withdrawal avoids is now a recorded fence. The withdrawn proposal wanted to rebase WitnessStream from VERSION order into "address-scoped stream order", possibly repurposing VersionRange -- exactly the semantic type drift the DOCK/ROUTE separation exists to prevent. Time is time; address is address; sharing a memory ABI does not make two topologies interchangeable. It also risked re-entering the memory escape: a "WitnessStream-shaped window" that materializes another Vec<(u64, CausalWitnessFacet)> is the same violation through a different door -- and wave.rs's own honesty note already says WitnessStream is TODAY a parallel OWNED container, not a zero-copy projection. 3. Two inherited assumptions dropped, neither established by the finding: - `rung = HHTL tree depth` -- the answerable question is whether depth is reconstructible from SUPPORT topology, which needs no address at all. - `stamp = commutative accumulation` -- Stamp's load-bearing behaviour is IDENTITY semantics (disjointness, overlap, source-set union, no-double-count, belief.rs:39-48, plus a modulo-64 fold that is conservative by design). A vsa_bundle-style fold is not automatically a source-set union. 4. tarski-markov-hhtl-seam-v1.md is no longer a plan. It is an open-questions register (Q1-Q5) with standing fences, explicitly licensing no work. Q5 is deliberately "is there a mechanism neither candidate resembles" -- the question nobody has asked, and the most likely place a real answer lives. 5. The falsifiers SF1-SF5 are gone with the plan they gated. Pre- registering falsifiers for a mechanism nobody has licensed is premature precision. Also corrects a factual error in the previous PR body, which described #1006 as merged. It is open, and this branch's base is the #1005 plateau -- so this branch does NOT contain the Step 1 audit it cites. The citation stands as a cross-reference to an open PR, not a dependency. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01KCGhDYoQBXs3poaR7sFuqp --- .claude/board/EPIPHANIES.md | 56 +++-- .claude/board/INTEGRATION_PLANS.md | 43 ++-- .claude/plans/tarski-markov-hhtl-seam-v1.md | 230 ++++++++------------ 3 files changed, 164 insertions(+), 165 deletions(-) diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 2beb6fe50..8f7991be8 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -65,21 +65,51 @@ 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, stated precisely so Step 3 doesn't restate either -candidate by mistake.** If the operator's ruling is to be built rather -than merely re-asserted, Step 3's probe cannot pick ONE of these two -shipped mechanisms and call it done — neither is the fold. It would need -to COMPOSE them: a stream-order Markov reading (candidate A's window/ -offset walk) BOUND to a specific tree address (candidate B's prefix -containment, so "depth" and "which subtree" are meaningful at all) — -which is itself a new, undocumented seam, not a restatement of anything -shipped. Flagged as a future integration item, not built here (Step 1's -own scope: audit-first, no layout invented). +**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 canonizing on either candidate as sufficient. See -`.claude/plans/tarski-markov-hhtl-seam-v1.md` for the deferred integration -plan this finding motivates. +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 diff --git a/.claude/board/INTEGRATION_PLANS.md b/.claude/board/INTEGRATION_PLANS.md index 3f8033083..d87b0dfa6 100644 --- a/.claude/board/INTEGRATION_PLANS.md +++ b/.claude/board/INTEGRATION_PLANS.md @@ -1,22 +1,33 @@ -## 2026-08-23 — TARSKI-MARKOV-HHTL-SEAM-1 (deferred, gated on BELIEF-ABI-RESTORATION-1 Step 2) +## 2026-08-23 — TARSKI-MARKOV-HHTL (open-questions register — HELD, not a plan) -`.claude/plans/tarski-markov-hhtl-seam-v1.md` — names the seam a future -`BELIEF-ABI-RESTORATION-1` Step 3 must build, motivated by +`.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` (HHTL depth + accumulate -from children/siblings) has NO shipped implementation, and its two closest -candidates are different topologies that both explicitly fall short — -`deepnsm-v2::wave::WitnessStream` is a stream-order Markov reading that -disclaims accumulation by name (`E-NO-BUNDLE-STANDING-WAVE-1`); -`AttentionFocusFacet` is a prefix-tree containment reading (`covers`/ -`common_prefix`) with no fold operator. Step 3 must COMPOSE a stream-order -reading bound to a tree address, not restate either. Falsifiers SF1-SF5 -pre-registered; PROBE-TARSKI-SIGNED-WITNESS-1 and -PROBE-FOUR-PLANE-CAUSAL-MEDIUM-1 (both #1007) are named as reusable, -already-proven inputs. **Explicitly deferred** — do not start until -`BELIEF-ABI-RESTORATION-1` Step 2 (operator ruling on the Step 1 residue) -lands; this plan is input to that ruling, not a substitute. +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) diff --git a/.claude/plans/tarski-markov-hhtl-seam-v1.md b/.claude/plans/tarski-markov-hhtl-seam-v1.md index c0bc16edd..02581aad5 100644 --- a/.claude/plans/tarski-markov-hhtl-seam-v1.md +++ b/.claude/plans/tarski-markov-hhtl-seam-v1.md @@ -1,144 +1,102 @@ -# TARSKI-MARKOV-HHTL-SEAM-1 — a stream-order reading bound to a tree address +# TARSKI-MARKOV-HHTL — open questions register (NOT a plan) -> Status: DEFERRED INTEGRATION ITEM. Named, not built. Gated on -> `BELIEF-ABI-RESTORATION-1` Step 2 (operator ruling on the Step 1 residue) -> landing first — this plan is the eventual Step 3 probe's design surface, -> not a replacement for it. +> 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. -## The gap this plan names +## What is established -`BELIEF-ABI-RESTORATION-1`'s Step 1 audit (`.claude/plans/belief-abi-restoration-v1.md`, -merged in #1006) found that the operator-ruled delegation for -`Belief.rung`/`stamp` — *"rung = HHTL tree depth, stamp = accumulate from -children and siblings, inherit from parent"* — names a mechanism that does -not exist in code. A follow-up asked whether either of the two closest -shipped candidates already IS that mechanism. Grounding both -(`.claude/board/EPIPHANIES.md`, -`E-STREAM-ORDER-VS-PREFIX-TREE-NEITHER-ACCUMULATES-1`) found: no. +`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: ``` - Candidate A: deepnsm-v2::wave::WitnessStream (G24N4 / Markov) - events: Vec<(u64, CausalWitnessFacet)> — flat, append-ordered - ground_at / resolve_at: signed-offset walk within a VERSION window - explicit refusal to accumulate (E-NO-BUNDLE-STANDING-WAVE-1): - "there is no accumulator and no shared register" - → a TOTAL ORDER over time. No tree. + 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) - Candidate B: AttentionFocusFacet (AriGraph / HHTL basins) - covers / common_prefix — coarse→fine PREFIX containment - answers "is A an ancestor of B" / "what do A, B share" - never "what do B's children contribute to A" - → a PARTIAL ORDER over address. No fold. + 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" ``` -Neither candidate accumulates. The operator's ruling therefore describes a -mechanism that must be BUILT by composing the two, not selected from -what already exists. - -## The seam (sketched, not designed) - -``` - HHTL address (Candidate B) - │ gives: which subtree, what "depth" means, ancestor/descendant - ▼ - a per-address WitnessStream-shaped window (Candidate A's machinery, - rebased from "version order" to "address-scoped stream order" — - the events visible to a fold are the ones IN that subtree, ordered - however the fold needs, not necessarily by version) - │ gives: a bounded, single-owner sequence to walk/reduce - ▼ - an accumulate operator over that sequence - (children's registers → parent's register; NOT `MergeMode::Xor`, - per I-SUBSTRATE-MARKOV — magnitude-side accumulation is `vsa_bundle` - or an equivalent commutative fold, never raw XOR) - │ - ▼ - Belief.rung / Belief.stamp AS A PROJECTION of the folded result, - never a separately-stored field -``` - -Every arrow above is a genuine design decision, not a restatement: - -1. **Is the per-address window literally `WitnessStream` re-scoped, or a - new type?** `WitnessStream::window_range` already takes an arbitrary - `VersionRange` — whether an "address range" (an HHTL subtree) can be - expressed as a re-purposed version-like ordering, or needs its own - window abstraction, is open. -2. **What is the fold?** `carried_awareness`, the Horner sum in - `rail_geometry.rs:183`, and `causal_audit`'s append-only history were - each checked in Step 1 and shown to be a DIFFERENT mechanism from - "children+siblings accumulate, inherit from parent" — none is a - template to copy. The fold itself is undesigned. -3. **Does `rung` become a read-time query over the fold, or does the fold - get materialized per address?** The zero-copy-warden's law ("zero - copy is a law without escape hatches... the array itself is a - ClassView projection") argues for read-time; but a fold that walks an - unbounded subtree on every read is a real cost question, not yet - measured. -4. **Does this replace `BeliefArena.rung: u32` entirely, or does `rung` - become `support_ceiling()` over a resident G24N4 register as - `PROBE-TARSKI-SIGNED-WITNESS-1` already demonstrates (PR #1007), with - the HHTL-address binding as a SEPARATE, later-composed axis?** These - are not obviously the same migration. The Tarski-signed-witness probe - proved the SIGN/MAGNITUDE reading works over a resident register with - no address at all (a flat `Dock` array, no `FacetCascade` address - minted per belief). Binding that register to a real HHTL address is - an ADDITIONAL step this plan is scoping, not one already done. - -## What is already proven and can be reused as-is - -- `PROBE-TARSKI-SIGNED-WITNESS-1` (PR #1007): the G24N4 signed reading - (`SupportedBy`/`Contradiction` as depth, not magnitude) reproduces - `Belief::rung` exactly on the positive lane, and retains what the - shipped `admit_derived` CHOICE law provably discards. This is the - EVIDENCE-content half of the eventual fold's input — settled, reusable. -- `PROBE-FOUR-PLANE-CAUSAL-MEDIUM-1` (PR #1007): proves the four-plane - separation (WHERE / WHAT / WHICH-LENS / WHY) composes over disjoint - lanes of one resident row without any plane auto-deriving another. This - is the discipline the eventual fold must respect: an accumulate - operation over the WHY plane must not silently rewrite the WHAT/WHICH - planes, exactly as `PROBE-FOUR-PLANE-CAUSAL-MEDIUM-1`'s FP3 already - requires for a single row. -- The A9 "loci, not magnitudes" law and the DOCK/ROUTE separation - (`E-TYPE-COMPLEXITY-EXPOSED-A-MEMORY-ABI-ESCAPE-1`) bound the shape any - new reading must take: classid chooses the reading, the route chooses - the traversal, the bytes never change shape. - -## What this plan does NOT do - -- Does not mint a tenant, a classid, or a `CascadeShape` variant. -- Does not implement the fold. This is a design surface, not a probe. -- Does not resolve open questions 1-4 above — they are the actual content - of a future Step 3, and should be answered by a probe with pre-registered - falsifiers (per this repo's own standing falsifiability rule: "a guard - that fires on everything carries exactly as much information as one - that never fires" — an accumulate-fold that always reproduces - `max(premise rungs)+1` regardless of tree shape has proven nothing). - -## Falsifiers a Step-3 probe against this seam must clear - -- **SF1** — the fold, bound to a real per-belief HHTL address, reproduces - `BeliefArena`'s CURRENT `rung = max(premise rungs)+1` on the positive-only - corpus (parity oracle, same shape as `PROBE-TARSKI-SIGNED-WITNESS-1`'s - A1/A2 gates). -- **SF2** — the fold survives a NON-trivial tree shape (siblings with - different depths, a node with zero children) without collapsing to a - constant — the anti-vacuity discipline this repo's `CLAUDE.md` - ("the falsifiability rule") already mandates for any new guard/fold. -- **SF3** — accumulation uses a commutative operator (`vsa_bundle` or - equivalent), never raw XOR on the magnitude side, per - `I-SUBSTRATE-MARKOV`. -- **SF4** — binding an address to a belief does not retroactively change - any OTHER plane of that belief's row (FP3's discipline, generalized). -- **SF5** — if SF1-SF4 cannot all be cleared, the probe reports the EXACT - missing bit/field/route invariant (per the charter's own instruction: - "report the exact falsifier if it cannot reproduce the arena's current - rung/stamp results. Do not force it.") rather than silently degrading - the parity requirement. - -## Trigger to promote this from "named" to "active" - -Do not start this until `BELIEF-ABI-RESTORATION-1` Step 2 (the operator -ruling on the Step 1 residue table — `premises`, `stmt`/`truth`, and this -tree-overlay mechanism, itemized) has landed. This plan is input to that -ruling, not a substitute for it. +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."* + +## 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. From 55ae17ead7ce06562c26bd0e83c2e18e56b52b88 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 23 Aug 2026 18:32:44 +0000 Subject: [PATCH 3/3] regrade: the stream-vs-tree opposition was overstated Applies E-HIERARCHY-IS-THE-ADDRESS-SPACE-NOT-THE-ONTOLOGY-1 to this entry, in place, append-only (regraded, not rewritten or deleted). This entry framed stream-order-over-time and prefix-tree-over-address as an OPPOSITION, as if a datum had to live in one universe or the other. Too strong. Under the address-space law 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 that addressed neighborhood. Stream ordering remains temporal semantics; HHTL supplies the home. Layered, not rival. What survives unchanged -- the entry's actual result: neither candidate implements a children-and-siblings accumulate fold (zero hits for fn accumulate / children.*sibling; E-NO-BUNDLE-STANDING-WAVE-1 disclaims accumulation by name). Both [ABSENT] verdicts stand. Also unchanged: the withdrawal of the composition conclusion. The regrade REMOVES the motivation for that composition rather than reviving it -- the proposal wanted to re-scope a version-ordered type to mean an address span, and the address-space law says the right move was always to give the temporal datum its own address and leave the ordering alone. The type-drift fence is strengthened, not relaxed. Confidence line split: high for the [ABSENT] verdicts, lowered for the "different topologies" framing. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01KCGhDYoQBXs3poaR7sFuqp --- .claude/board/EPIPHANIES.md | 31 +++++++++++++++++++-- .claude/plans/tarski-markov-hhtl-seam-v1.md | 20 +++++++++++++ 2 files changed, 48 insertions(+), 3 deletions(-) diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 8f7991be8..4e92d4540 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -2,9 +2,34 @@ **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). -**Confidence:** High — every claim below is grep- and read-verified against -shipped code, not inferred from module-doc prose alone. +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 diff --git a/.claude/plans/tarski-markov-hhtl-seam-v1.md b/.claude/plans/tarski-markov-hhtl-seam-v1.md index 02581aad5..1af89b8d5 100644 --- a/.claude/plans/tarski-markov-hhtl-seam-v1.md +++ b/.claude/plans/tarski-markov-hhtl-seam-v1.md @@ -52,6 +52,26 @@ accumulate operator. **Withdrawn**, for three reasons: 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