D-HOLO H14b (withdrawn): positional lane mask M; measurements kept, no layout verdict

.claude/board/AGENT_LOG.md

@@ -1,3 +1,8 @@
+## 2026-10-15 — D-HOLO H14b result count: one census run
+
+- Card `census-counter` (run as a general-purpose agent on Haiku with the card's rules pasted), the H14b table of `h14b_run1.txt`, lines 59–94: k <= 4 cells, cells above 1.25× B on full-row and session read, min/max per density, F3 and byte comparisons.
+- Ledger: every count matched the orchestrator's independent awk run (9 failing cells, same cells and ratios); 0 wrong, 0 missed. One cosmetic defect: its echo labels were shell-expanded; the counting commands were unaffected. About 396k subagent tokens. No conclusion came from the card.
+
 ## 2026-10-15 — ledger-correction batch: two Haiku harvest runs
 
 - Card `harvest-scout` over ndarray `src/hpc/*cascade*` + blackboard (O20): hits at `cascade.rs:270-276`, `:813`, blackboard `:84-90` read and confirmed; 0 wrong, 0 missed. Earlier in the session the doc scout returned counts without hits (one miss on that kind of task).

.claude/board/STATUS_BOARD.md

@@ -42,7 +42,8 @@ Plan: `.claude/plans/relalg-v1.md`. Crate: `crates/lance-graph-relalg` (own work
 | **D-HOLO-H9** | Relational emptiness decided symbolically (empty operand, disjoint domains, contradictory constraints) vs by fold | Queued (pre-registered, not run) | zero false empties; fraction decided symbolically reported |
 | **D-HOLO-H11** | Stacked logic: a chain of NAL polyfill bricks at depth 1–8 composed before one evaluation | Queued (pre-registered, not run; after H6b) | answers no single brick gives, == oracle; cost below d separate runs at d = 4; no confidence inflation, gate disable must inflate |
 | **D-HOLO-H12** | Semantic map of inference functions across OpenNARS, ONA, the NAL polyfill (and a MeTTa NAL if pinnable) | Queued (pre-registered, not run) | last system adds zero nodes in both orders; polyfill gaps named; differences classified as distinction or defect |
-| **D-HOLO-H14** | Per classid x thought x 64k tile: full 512-byte row writes vs a connected lane delta (row key + lane mask + changed lanes in one record), and per-(thought, lane) tables indexed directly by the row address (`Lane_l[index]`, no traversal; presence masks folded, materialization charged only at a terminal); session thought masks and thought lane masks kept as separate levels | Measured 2026-10-15 (v4, one class): C folds 10–256× faster than B on F1/F2; C merge-on-read 2.8–6.1× slower than B; C default and B default both not met; returned to the operator with the crossover; H14b (positional per-row lane mask for C) open | == dense reference; C default iff at k <= 4 its fold queries are >= 2x faster than B, its reads with terminal materialization <= 1.25x B and bytes <= B; else B default iff read and session read <= 1.25x A and bytes <= 0.5x A; mixed result returns to the operator |
+| **D-HOLO-H14** | Per classid x thought x 64k tile: full 512-byte row writes vs a connected lane delta (row key + lane mask + changed lanes in one record), and per-(thought, lane) tables indexed directly by the row address (`Lane_l[index]`, no traversal; presence masks folded, materialization charged only at a terminal); session thought masks and thought lane masks kept as separate levels | Measured 2026-10-15 (v4, one class): C folds 10–256× faster than B on F1/F2; C merge-on-read 2.8–6.1× slower than B; C default and B default both not met; returned to the operator with the crossover; H14b measured (row D-HOLO-H14b) | == dense reference; C default iff at k <= 4 its fold queries are >= 2x faster than B, its reads with terminal materialization <= 1.25x B and bytes <= B; else B default iff read and session read <= 1.25x A and bytes <= 0.5x A; mixed result returns to the operator |
+| **D-HOLO-H14b** | C plus one positional u32 lane mask per row per thought (`Mask[i]`), so merge-on-read reads only the tables the mask names; folds unchanged | Measured 2026-10-15 (v4, one class, entry 2026-10-15-d-holo-h14b-lane-mask): prediction falsified in 9 of 18 cells at k <= 4 (all 1 % cells pass, failures at 10 % and 100 % dirty); bytes <= B everywhere; M faster than C on full-row read in 35 of 36 cells; M beats B on F3 in all 12 cells at 1 % dirty; M default not met. WITHDRAWN 2026-10-15 as a layout candidate (category error: M transposes C's presence planes into a row index; H14/H14b measured row reconstruction, not C's primary operation); numbers kept; follow-up D-HOLO-H14c | M default iff at k <= 4 on every cell its full-row and session read <= 1.25x B and bytes <= B; folds equal C (tested) |
 | **D-RA-1** | `Rel` + `normalize` + `symbolic` + R2IL lowering | Shipped #1546 `c21bd165` (11 tests, 11 disable runs red; four comparisons on one lane 8 → 2 ops; 70/2,000 small descriptions refused as written, all run rewritten) | == row oracle over 400 generated descriptions × 5 measures |
 | **D-RA-2** | Rules into the contract set IR (D-CMR-1/-6); relalg keeps only lowering or is deleted | Queued (maintainer decision) | relalg tests pass unchanged against the contract IR |
 | **D-RA-3** | Datalog rules as algebra values; names are labels resolved through the label codebook, never strings in a rule | Queued (after D-RA-2) | codebook-built rules == hand-written `Rel`; unknown label refused at resolution |

.claude/board/entries/2026-10-15-d-holo-h14b-lane-mask.md

@@ -0,0 +1,28 @@
+# D-HOLO-H14b — inverted fold plus a positional lane mask per row (v4, 2026-10-15)
+
+**Status:** MEASURED. Plan: `.claude/plans/d-holo-address-indexed-algebra-v1.md` (H14b, pre-registered before the run, results).
+**Probe:** `crates/lance-graph-mask-risc/examples/holo_lane_storage_probe.rs` (arm M); `tier: v4 (avx512f)`; A, B, C and M timed in one run on one host; one class.
+
+- Prediction (M's full-row and session read <= 1.25× B at k <= 4):
+  FALSIFIED in 9 of 18 cells. At 1 % dirty all 6 cells pass (full-row
+  0.94–1.14× B, session 0.93–1.13×); failures at 10 % dirty (up to 1.40 /
+  1.87×) and 100 % dirty (up to 1.63 / 5.85×). M's bytes to the writer are
+  at most B's in every cell, by construction rather than measurement (B was
+  charged a `starts` offset per dirty row that M was not; under the same
+  accounting they are equal). M default not met; returns to the operator.
+- The mask fixed most of C's merge cost: M's full-row read is faster than C's
+  in 35 of 36 cells (C/M 0.98–3.69×).
+- F3 (fold, then build the named rows): M beats B in all 12 cells at 1 %
+  dirty and in 18 of 36 overall; M beats C in 33 of 36.
+
+**OPEN:** why M loses at higher density (HYPOTHESIS: a row's k lanes sit in k
+tables, B's in one record); C's and M's seal at 1 % dirty is page-fault
+bound; 16 classes untimed.
+
+**Withdrawal note (2026-10-15, before merge).** M is withdrawn as a candidate
+default layout for thought-first C, and the density-based A/B/C/M switch is
+withdrawn. H14 and H14b mostly measured whole-row reconstruction, which is not
+C's primary operation; `Mask[i]` transposes what C's per-lane presence planes
+already hold into a row-oriented index. The numbers above stand; their reading
+as a verdict on C does not. M remains an experimental row-oriented acceleration
+structure. Follow-up: D-HOLO-H14c. Full note: the plan's "H14b withdrawal note".

.claude/board/entries/README.md

@@ -25,13 +25,14 @@ index row, (3) no duplicate entry id. Checks 1 and 2 are deliberately
 opposite directions; the stranding this convention prevents shows up in
 exactly one of them, never both.
 
-343 entries, 2026-08-06 .. 2026-10-15.
+344 entries, 2026-08-06 .. 2026-10-15.
 
 | date | entry id | finding | file |
 |---|---|---|---|
 | 2026-10-15 | `ledger-correction-wire-contract` |  | [2026-10-15-ledger-correction-wire-contract.md](2026-10-15-ledger-correction-wire-contract.md) |
 | 2026-10-15 | `givens-layer` |  | [2026-10-15-givens-layer.md](2026-10-15-givens-layer.md) |
 | 2026-10-15 | `D-WAL` | `LanceCycleWriter` vs the lancedb 0.40 MemWAL write path (measured) | [2026-10-15-d-wal-shootout.md](2026-10-15-d-wal-shootout.md) |
+| 2026-10-15 | `D-HOLO-H14b` |  | [2026-10-15-d-holo-h14b-lane-mask.md](2026-10-15-d-holo-h14b-lane-mask.md) |
 | 2026-10-15 | `D-HOLO-H14` |  | [2026-10-15-d-holo-h14-lane-storage.md](2026-10-15-d-holo-h14-lane-storage.md) |
 | 2026-10-14 | `revision-layer-invariants` |  | [2026-10-14-revision-layer-invariants.md](2026-10-14-revision-layer-invariants.md) |
 | 2026-10-14 | `D-MTP-0` | where Hyperon/MeTTa attaches to the masking-algebra polyfill | [2026-10-14-metta-polyfill-map.md](2026-10-14-metta-polyfill-map.md) |

.claude/plans/d-holo-address-indexed-algebra-v1.md

@@ -1083,3 +1083,127 @@ What the numbers point at (HYPOTHESIS, not measured here):
 - C's seal at 1 % dirty is page faults: the positional tables are zeroed
   lazily, so each scattered dirty row touches a fresh page. At 100 % dirty
   the same seal costs 32–222 ns. Persisted bytes are unaffected.
+
+## Next falsifier: H14b — C with a positional lane mask per row (PRE-REGISTERED 2026-10-15, NOT RUN)
+
+Approved by the operator 2026-10-15 ("go ahead with H14b").
+
+**Arm M.** C's per-(thought, lane) tables and presence masks, unchanged, plus
+one `u32` per row per thought held positionally: `Mask[i]` names the lanes row
+i changed in that thought (0 for a clean row). The address stays the register:
+no index, no traversal. Folds are C's folds (the same presence masks).
+Merge-on-read reads `Mask[i]` and then position i of only the tables it names,
+instead of probing every touched table.
+
+Resident cost added per thought: 4 bytes per row (256 KiB per 64k tile).
+Bytes handed to the writer: per dirty row its key, its lane mask and the
+changed lanes (8 + 16k); per-lane positions follow from the masks.
+
+**Prediction.** At k <= 4, on every (dirty, thoughts) cell of the H14 grid,
+M's full-row read and M's session read are each at most 1.25× B's. Falsified
+if any such cell exceeds 1.25×.
+
+**Decision rule.** M becomes the default for a dirty tile if, at k <= 4 on
+every cell: the prediction holds; M's bytes to the writer are at most B's;
+and C's fold advantage (at least 2× B on F1 and F2) carries over, which holds
+by construction because M folds C's masks (checked by test, not re-timed). If
+the prediction fails, the result returns to the operator with the cells that
+failed and the F3 crossover between M and B.
+
+Also reported, not part of the rule: seal per dirty row, F3 per emitted row
+for M against A, B and C.
+
+**Comparisons are within one run.** A, B, C and M are timed in the same run on
+the same host with the tier printed. The H14 numbers (another host) are not
+compared against.
+
+**Tests before any timing.**
+- M reads the dense reference on every row (k = 1, 4, 31).
+- M's `Mask[r]` equals B's lane mask for every row r.
+- M's merge probes exactly `popcount(Mask[r])` tables for row r, and C's
+  merge probes every touched table; the fixture must have more touched tables
+  than k, or the test proves nothing.
+- M's F1, F2 and F3 equal C's.
+
+**Disable runs.** M's merge iterating the touched tables instead of `Mask[r]`
+must turn the probe test red. A mask that drops one lane must turn the
+reference test red.
+
+### H14b results (v4, 2026-10-15): the prediction fails above 1 % dirty; M is C's read fixed, not B's
+
+Run: `cargo run --release -p lance-graph-mask-risc --example
+holo_lane_storage_probe`; the program printed `tier: v4 (avx512f)`. A, B, C
+and M were timed in the same run on the same host (a different host from the
+H14 run, so the two runs are not compared). One class. 11 tests pass; the two
+pre-registered disable runs turned their tests red (M's merge over every
+touched table; a mask that drops a lane).
+
+**Rule at k <= 4 (18 cells).**
+- Prediction (M's full-row and session read each <= 1.25× B): **FALSIFIED**
+  in 9 of 18 cells. All 6 cells at 1 % dirty pass (full-row 0.94–1.14× B,
+  session 0.93–1.13×). The failures are at 10 % dirty (T = 8 k = 4: 1.40 /
+  1.34; T = 64: session 1.34–1.87) and at 100 % dirty (full-row up to 1.63×,
+  session up to 5.85×).
+- M's bytes to the writer <= B's: true in every cell, but by construction,
+  not as a measurement. Both arms carry the same values; B was also charged a
+  4-byte `starts` offset per dirty row that M was not, although both can
+  derive per-lane positions from the masks. Under the same accounting the two
+  are equal, so this part of the rule carried no evidence (review of #1569).
+- Folds: M uses C's presence masks; tested equal, not re-timed.
+- M default: **not met.** Returns to the operator.
+
+**What M did change.** Against C in the same run, M's full-row read is
+0.98–3.69× as fast (C/M): faster in 35 of 36 cells, from 297.4 vs 209.8 ns
+(T = 1, 1 %, k = 1) to 1,129 vs 306 ns (T = 64, 1 %, k = 1); the one cell
+where C is faster is T = 1, 100 %, k = 31 (1,299 vs 1,320 ns). On F3 (fold,
+then build the rows the fold names), M beats C in 33 of 36 cells and B in
+18 of 36. At 1 % dirty M is the cheapest arm in 10 of 12 cells (M 84–184 ns
+per emitted row, B 175–1,260, C 123–241); C is cheaper at k = 31 for 1 and 8
+thoughts.
+
+**Where M loses (HYPOTHESIS, not measured).** B keeps a row's changed lanes
+next to each other in one record, so a row read is one index lookup and one
+or two cache lines. M keeps lane l of row i in table l at position i, so a
+row with k changed lanes is k cache lines in k tables. That costs little when
+few rows are dirty and grows with density; the session read at 8–64 thoughts
+also walks up to T × k tables at once. A test would be to time the read
+against k at fixed density and count cache misses per row.
+
+**Crossover.** At 1 % dirty, M matches B on reads (within 1.25× in all 6
+cells at k <= 4) and beats B on F3 in all 12 cells; at 10 % and above, B's
+reads are faster. M's seal at 1 % dirty is still the
+page-fault cost of C's positional tables (6.5–15 µs per dirty row at one
+thought).
+
+### H14b withdrawal note (2026-10-15): M withdrawn as a layout candidate; the numbers stand, their reading as a verdict on C does not
+
+DECISION (operator, 2026-10-15: "I think M is a categorical error"). SCOPE: the
+default-layout question for thought-first C. BASIS: below. REVISIT WHEN: a
+consumer is shown that genuinely needs whole-row reconstruction as its primary
+operation.
+
+1. **M is withdrawn as a candidate default layout for C.** It stays in the probe
+   as an experimental, row-oriented acceleration structure. It is not a
+   prerequisite for Cartesian operand addressing.
+2. **The density-based A/B/C/M layout switch proposed after H14b is withdrawn.**
+3. **H14 and H14b mostly measured whole-row reconstruction** (full-row read,
+   session read, F3 materialization). That is not C's primary operation. In C a
+   thought program names the lane tables it needs, and each is read at the shared
+   address: `Thought(t)[Table(a)[i] : Table(b)[i]]`. No row is assembled unless a
+   named terminal asks for one.
+4. **What M adds is a transposition, not new information.** `Mask[i]` restates,
+   row by row, what C's per-(thought, lane) presence planes already hold column
+   by column: bit l of `Mask[i]` equals bit i of `P_{t,l}`. Storing it again,
+   per row, reintroduces row-first discovery ("which lanes does this row have?")
+   in front of positional access.
+5. **Two facts are distinct.** The thought knows which lanes its program
+   *requests*; it does not need to know which lanes are *populated* at a row.
+   C answers the second question with the presence bit of each requested table,
+   one test per requested lane, never by scanning the touched tables.
+6. **The measurements are not invalid.** Every number above stands as measured.
+   What is withdrawn is their interpretation as a verdict on whether C works.
+   The open hypothesis from H14 ("the merge probes every touched table") is
+   itself an artifact of the full-row question: a query-shaped read probes only
+   the tables its program selects.
+7. The follow-up falsifier is **H14c** (thought-first positional reads, Hamming
+   presence, Lance 13 masked I/O), run on its own branch and PR.