Disposition doc for eigentrust pitfalls #8/#9/#10/#16 (observations) - #7
Closed
kumavis wants to merge 2 commits into
Closed
Disposition doc for eigentrust pitfalls #8/#9/#10/#16 (observations)#7kumavis wants to merge 2 commits into
kumavis wants to merge 2 commits into
Conversation
The 2026-04-23 eigentrust pitfalls memo (forthcoming branch) enumerated 16 items hit during the EigenTrust implementation. Items #1-7 and #11-15 are language/elaboration defects with their own PRs. Items #8, #9, #10, and #16 are observations rather than Prologos defects; no compiler change is needed for them but the memo deserves a parallel disposition note so a future reader does not double-count them as open work. #8 (exact-Rat slow on deep iter): intrinsic to exact rational arithmetic; benchmark-scope guidance, not a fix. #9 (Posit32 literals work): positive observation; `~` literal prefix is unambiguous unlike `0/1`. No action. #10 (PVec preserves where List does not): subsumed by pitfall #3 fix. After #3 lands, both literal forms preserve element type uniformly. Close as duplicate. #16 (column-stochastic vs row-stochastic): algorithm/spec clarification, not a Prologos defect. The eigentrust implementation branch already takes column-stochastic M directly and validates via col-stochastic?. https://claude.ai/code/session_01MbncYJnrvjzhbVWw4xGi5x Co-authored-by: kumavis <1474978+kumavis@users.noreply.github.com>
Cherry-picked from PR #2 (commit f3a3ca3). The benchmark file references the pre-D.5b TMS API (`tms-write`, `tms-cell-value`, `tms-read`, `tms-commit`) which was removed when the TMS was refactored into the `tms-cell` struct + `atms-write-cell` interface. The file is a historical baseline-measurement artifact (Pre-0 micro-benchmark) that does not run in CI or the regression suite, but `raco pkg install --auto` compiles every .rkt in the collection, so its unbound-identifier error fails the build. Add `racket/prologos/benchmarks/micro/info.rkt` with `compile-omit-paths '("bench-bsp-le-track2.rkt")` so `raco setup` skips it. This is a minimal CI-unblock; the full migration to the current TMS API is out of scope for this PR (same as f3a3ca3's scope). Without this, PR #4 (and the other pitfall PRs branched from main) all fail CI in the `raco pkg install` step. https://claude.ai/code/session_01MbncYJnrvjzhbVWw4xGi5x Co-authored-by: kumavis <1474978+kumavis@users.noreply.github.com>
Contributor
Author
|
you can skip this one |
kumavis
added a commit
that referenced
this pull request
Apr 26, 2026
…defn Pre-fix: `defn f | cons r nil -> r | cons r rest -> ...` parsed each bare token after `|` as a separate arg pattern, splitting the function into clauses with mismatched arities (1 nil clause + 2 cons-3-arg clauses). This produced a per-clause helper (`f::1`, `f::3`) and the recursive call site `[f rest]` failed with `Unbound variable f::1` because the arity-1 helper only knew the nil clause and any non-empty list hit __match-fail. Fix shape (a) — implement general pattern matrices by auto-packing when the leading bare token names a known constructor whose field count matches the remaining tokens. `cons r nil` → one compound pattern `pat-compound 'cons (var-r, var-nil)` (then normalize-pattern converts var-nil to compound-nil since nil is a known nullary ctor). Fallback preserved for genuinely multi-arg defns: defn add | x y -> [+ x y] The leading `x` is a variable (lookup-ctor returns #f), so falls through to the old N-arg interpretation. Trade-off vs (b) (raise an error): (a) makes the syntax do what ML/Haskell users expect — `defn` IS the primary dispatch mechanism per .claude/rules/prologos-syntax.md, so making `cons r nil` mean "compound pattern" is the natural reading. The detection is local and does not change semantics for any pattern that didn't have a known ctor as its leading token. Scope: 23 lines in parser.rkt's parse-defn-clause + 11 new tests in test-defn-multiarg-patterns.rkt. No changes elsewhere. Test results: 11/11 new tests pass. 43/43 related tests pass (test-pattern-defn-01, test-pattern-defn-02, test-multi-body-defn). Full affected-suite: 4646 tests in 255 files, 1 unrelated pre-existing failure (stale tracking entry for non-existent test-constraint-retry-propagator.rkt). Latent issue exposed (NOT introduced by this fix): compile-match-tree binds variable patterns to outer-param names when those params get destructured by a later dispatch column. E.g., `cons r rest` after outer-cons specialization tries `let rest := __cons_1` while `__cons_1` is being destructured into `__cons_1_0` and `__cons_1_1`. This affects the recursive bodies of the eigentrust example with multi-element inputs, but is a pre-existing bug in compile-match-tree — reproducible on main with the bracketed `[cons r rest]` form, which parses to the same internal representation. The new tests cover the slices unaffected by this bug (empty + singleton inputs, wildcard patterns, all-var multi-arg) and explicitly call out the latent issue. Co-authored-by: kumavis <1474978+kumavis@users.noreply.github.com>
kumavis
added a commit
that referenced
this pull request
Apr 26, 2026
…defn Pre-fix: `defn f | cons r nil -> r | cons r rest -> ...` parsed each bare token after `|` as a separate arg pattern, splitting the function into clauses with mismatched arities (1 nil clause + 2 cons-3-arg clauses). This produced a per-clause helper (`f::1`, `f::3`) and the recursive call site `[f rest]` failed with `Unbound variable f::1` because the arity-1 helper only knew the nil clause and any non-empty list hit __match-fail. Fix shape (a) — implement general pattern matrices by auto-packing when the leading bare token names a known constructor whose field count matches the remaining tokens. `cons r nil` → one compound pattern `pat-compound 'cons (var-r, var-nil)` (then normalize-pattern converts var-nil to compound-nil since nil is a known nullary ctor). Fallback preserved for genuinely multi-arg defns: defn add | x y -> [+ x y] The leading `x` is a variable (lookup-ctor returns #f), so falls through to the old N-arg interpretation. Trade-off vs (b) (raise an error): (a) makes the syntax do what ML/Haskell users expect — `defn` IS the primary dispatch mechanism per .claude/rules/prologos-syntax.md, so making `cons r nil` mean "compound pattern" is the natural reading. The detection is local and does not change semantics for any pattern that didn't have a known ctor as its leading token. Scope: 23 lines in parser.rkt's parse-defn-clause + 11 new tests in test-defn-multiarg-patterns.rkt. No changes elsewhere. Test results: 11/11 new tests pass. 43/43 related tests pass (test-pattern-defn-01, test-pattern-defn-02, test-multi-body-defn). Full affected-suite: 4646 tests in 255 files, 1 unrelated pre-existing failure (stale tracking entry for non-existent test-constraint-retry-propagator.rkt). Latent issue exposed (NOT introduced by this fix): compile-match-tree binds variable patterns to outer-param names when those params get destructured by a later dispatch column. E.g., `cons r rest` after outer-cons specialization tries `let rest := __cons_1` while `__cons_1` is being destructured into `__cons_1_0` and `__cons_1_1`. This affects the recursive bodies of the eigentrust example with multi-element inputs, but is a pre-existing bug in compile-match-tree — reproducible on main with the bracketed `[cons r rest]` form, which parses to the same internal representation. The new tests cover the slices unaffected by this bug (empty + singleton inputs, wildcard patterns, all-var multi-arg) and explicitly call out the latent issue. Co-authored-by: kumavis <1474978+kumavis@users.noreply.github.com>
hierophantos
added a commit
that referenced
this pull request
Apr 27, 2026
…-marg parser: disambiguate bare-token compound patterns in defn (eigentrust pitfall #7)
kumavis
pushed a commit
that referenced
this pull request
Apr 27, 2026
Per user review of #0-#10: many entries were either out-of-scope (env limitations, not Prologos issues) or wrong (claims I never actually tested). Re-tested every claim against a real Racket and revised the doc. Numbers are reserved per the user's instruction — entries marked DELETED keep their slot so cross-refs don't drift. Detail: #0 DELETED — out-of-scope (Racket toolchain not in sandbox). Environment limitation, not a Prologos issue. #1 REFRAMED — was "capability subtype + promise resolution composition." Re-titled to honestly reflect what this actually is: an OCapN-side Phase 0 deferred-implementation note (eventual cross-vat receive isn't wired up yet). NOT a Prologos bug. #2 DELETED — false claim. Tested with a real Racket: WS-mode wildcard match `match | _ -> body` on user data types elaborates AND evaluates correctly when the function carries a proper `spec`. The `prologos::data::datum` comment I cited applies to a narrower polymorphic-context case, not a blanket wildcard ban as I asserted. Cleanup of behavior.prologos (~250 -> ~70 LOC) follows. #3 DELETED — false claim. Tested: `data Step step : [Nat -> Nat]` (with bracketed function type per the lseq-cell convention) accepts a function value, including closures with captured state. Open-world actor behaviour storage IS supported. The closed-enum BehaviorTag in our implementation was a needless workaround driven by this incorrect pitfall. Cleanup tracked separately. #4 KEPT, REFRAMED — real, narrowed claim. grammar.ebnf §6 lines 1153/1187/1199 promise `Mu` (sexp) and `rec` (WS) for recursive sessions. Both elaborate to `Unknown session type: rec` / `Mu`. So pitfall #4 is now: "rec/Mu in grammar but not in elaborator." CapTP's stream-level well-typedness is therefore the documented ceiling; per-exchange sub-protocols remain the workaround. #5 KEPT — `none`/`some` need explicit type args in some inference contexts. Real ergonomics tension, accurately documented. #6 DELETED — out-of-scope. WS-mode `let p := body` and sexp-mode `(let (p v) body)` are TWO surface forms by design (grammar.ebnf §7 line 1236). User-error, not a Prologos bug. #7 DELETED — was a quantitative restatement of #2. With #2 recanted, #7 evaporates: behavior modules can be wildcard-collapsed, dropping ~180 LOC. #8 DELETED — false claim. Tested: `data Box1 box1 : [Sigma [_ <Nat>] Bool]` and `data Table table : Nat -> [List [Sigma [_ <Nat>] Bool]]` both elaborate cleanly. The named-struct ActorEntry/PromiseEntry workaround in vat.prologos was unnecessary; can be simplified back. #9 DELETED — user error. `def` for value bindings vs `defn` for functions is documented (grammar.ebnf §3 lines 189-190, prologos-syntax rules). Mis-using `defn` for a 0-ary constant isn't a Prologos bug. #10 DELETED — out-of-scope. Network sandbox blocking external docs is an environment limitation. #11-#20 were not in scope of this review and remain as-is for the user to review next.
kumavis
pushed a commit
that referenced
this pull request
May 4, 2026
Original PIR text claimed runtime/core/ contains the BSP scheduler. Wrong — actual runtime/core/ has only data structures (cell store + profile counters + format buffer). The BSP scheduler stayed in each kernel file (hybrid kernel's worklist + fire_against_snapshot + merge_pending_writes + swap_worklists are inlined in prologos-runtime-hybrid.zig). Stage 3 design called for core/bsp.zig (~150 LOC) + core/worklist.zig (~60 LOC) as Phase 1 deliverables. Actual Phase 1 extracted only cells.zig + profile.zig + format.zig. The factoring scope shrank silently — neither the implementing commit nor any subsequent commit acknowledged the gap. Surfaced when the user asked "what's in the hybrid core zig side?" during PIR review. Corrections: - §1 (What Was Built): explicit "data structures only" + cross-ref to wrong-assumption #9 - §2 (Stated Objectives): added "reality check on the design quote" flagging the drift - §3 delivered table: Phase 1 status changed to "✅ partial" - §4 timeline: Phase 1+3+4 line clarifies scheduler not extracted - §5 deferred: new row for BSP scheduler factoring - §8 D1 + anti-decision: caveat added; "BSP scheduler abstraction" claim corrected to "cell-store comptime-parameterization abstraction" - §9 #2: factoring narrative softened to "data structures only" - §11 #3: original kernel template + factoring made explicit at data-structure layer only - §12 #2 + #8: kernel-LOC framing corrected; "factored core LOC was bigger than expected" reframed to "smaller than expected — and the gap is the BSP scheduler" - §13 architecture: "consuming runtime/core/" framing softened to "consumes for cell store + profile + format helpers; the BSP scheduler is inlined" - §14 #3, #7, #8: "future kernels instantiate the same scheduler" claim corrected to "instantiate CellStore + reuse profile counters; each kernel still writes its own scheduler" - §15 technical debt: new row for "BSP scheduler not factored" - §17 wrong assumptions: new #9 "Phase 1 will factor the BSP scheduler into core" — Wrong; codifies the silent scope shrinkage - §18 #4: "factoring at second-instance" pattern reinforced with "complete vs minimum-viable shared surface" caveat - §21 lessons: new entry for "phase-close should compare delivered scope against design plan" - §24 open Q #4: kernel-PU consumption clarified — needs scheduler reuse in-place or triggers the extraction debt Errata block added at the top of the PIR documenting which sections were corrected and why. https://claude.ai/code/session_01Tycs6BWKG58Wo99YVPg6DF
kumavis
pushed a commit
that referenced
this pull request
May 4, 2026
Plan to factor preduce.rkt + preduce-hybrid.rkt into a backend-agnostic core (preduce-core.rkt) parameterized by a small backend interface. Two concrete backends — backend-racket (current preduce.rkt internals) and backend-hybrid (current preduce-hybrid.rkt FFI bridging) — wrap their respective primitives. preduce.rkt and preduce-hybrid.rkt become thin wrappers (~100 LOC each). Why now: - Phase 10/10b on hybrid is currently a port-not-wire-up because the two reducers have parallel compile-expr implementations - ~80 sites of (define-values (cid net) ...) threading in preduce.rkt vs side-effecting kernel-state in preduce-hybrid is the structural divergence to reconcile - After the refactor, OCapN-on-hybrid works for free via Racket callback fire-fns; profile-driven migration replaces hot callbacks with native individually - Pattern parallel to runtime/core/ factoring at the Zig layer (the BSP scheduler debt from hybrid PIR §15); same shape one layer up Plan structure: - §1 motivation + cost of duplication today - §2 audit — what's shared, what's specific (the threading-style divergence is the load-bearing decision) - §3 design — preduce-backend struct, two concrete backends, fire-fn-as-pure-value-fn signature inversion - §4 8-phase rollout (~9-11h total work; Phases 1-4 land the refactor, 5-8 validate + first migration on real workload) - §5 6 risks + mitigations (threading flip, bot-handling, tag exhaustion, test-suite churn, hybrid-backend bugs, perf regression) - §6 9 acceptance criteria - §7 what this doesn't solve (Zig-kernel unification, FFI economics unchanged, Phase 11+ still callback) - §8 connection to existing debt + the "factor at second-instance" pattern with three Racket-reducer consumers in mind - §9 progress tracker Acceptance criterion #7 is the user's stated goal: OCapN-syrup running end-to-end through the hybrid kernel with --profile showing where time is spent. Phase 6+7 deliver this. https://claude.ai/code/session_01Tycs6BWKG58Wo99YVPg6DF
kumavis
pushed a commit
that referenced
this pull request
May 4, 2026
…throughout) User challenged: "which threading model is appropriate to use both in and out of native?" The answer is functional — preserve preduce.rkt's (values cid net) discipline, have the hybrid backend wrap with a unit sentinel. Why functional, in-and-out-of-native: - SH Track 1 deliverable is ".pnet network-as-value" — networks become first-class cell values that round-trip - SH Track 9 (compiler-in-Prologos): compile-expr itself runs natively on propagators, with AST-cell input + network-cell output - Native fire-fns can't side-effect networks they don't hold; they must take net as input and produce net' as output - Side-effecting via current-prop-net is a bring-up convenience that becomes a dead-end at the SH endpoint - The current-bsp-fire-round? #f hack retires when the parameter becomes the threaded net itself (in native) Cost trade-off favors functional too: - Functional: preduce.rkt unchanged; backend-hybrid wraps with sentinel - Side-effecting: ~80-call-site flip in preduce.rkt - Both backends pass through fire-fn closures unchanged (still net-threaded) Plan revisions: - §2.3 reconciliation: flipped from "side-effecting under the hood" to "functional throughout"; added comparison table showing why functional fits native + cost is lower today - §3.1 interface: every primitive accepts and returns net; fire-fns unchanged from today (still net → net') - §3.2 backends: backend-racket uses prop-network struct; backend- hybrid uses 'hybrid sentinel; future backend-native uses cell-id as net (native dataflow) - §3.3 compile-expr sketch: structurally identical to today's preduce.rkt; only primitive-rename to b-alloc / b-install-fire-once - §4 rollout: simplified — Phase 2 (interface inversion) eliminated; total dropped from 9-11h to 8-10h - §5 risks: dropped #1 (threading-flip), refined #2 (bot-handling via b-read normalization), added #7 (current-bsp-fire-round? through FFI verification) - §9 tracker: 8 phases, this design doc done Critical implication for the hybrid backend: fire-fns stay net- threaded, which means make-reduce-fire's compile-and-bridge recursive compilation (which itself installs more propagators) just works through the abstract backend without modification. https://claude.ai/code/session_01Tycs6BWKG58Wo99YVPg6DF
kumavis
pushed a commit
that referenced
this pull request
May 4, 2026
Per user review of #0-#10: many entries were either out-of-scope (env limitations, not Prologos issues) or wrong (claims I never actually tested). Re-tested every claim against a real Racket and revised the doc. Numbers are reserved per the user's instruction — entries marked DELETED keep their slot so cross-refs don't drift. Detail: #0 DELETED — out-of-scope (Racket toolchain not in sandbox). Environment limitation, not a Prologos issue. #1 REFRAMED — was "capability subtype + promise resolution composition." Re-titled to honestly reflect what this actually is: an OCapN-side Phase 0 deferred-implementation note (eventual cross-vat receive isn't wired up yet). NOT a Prologos bug. #2 DELETED — false claim. Tested with a real Racket: WS-mode wildcard match `match | _ -> body` on user data types elaborates AND evaluates correctly when the function carries a proper `spec`. The `prologos::data::datum` comment I cited applies to a narrower polymorphic-context case, not a blanket wildcard ban as I asserted. Cleanup of behavior.prologos (~250 -> ~70 LOC) follows. #3 DELETED — false claim. Tested: `data Step step : [Nat -> Nat]` (with bracketed function type per the lseq-cell convention) accepts a function value, including closures with captured state. Open-world actor behaviour storage IS supported. The closed-enum BehaviorTag in our implementation was a needless workaround driven by this incorrect pitfall. Cleanup tracked separately. #4 KEPT, REFRAMED — real, narrowed claim. grammar.ebnf §6 lines 1153/1187/1199 promise `Mu` (sexp) and `rec` (WS) for recursive sessions. Both elaborate to `Unknown session type: rec` / `Mu`. So pitfall #4 is now: "rec/Mu in grammar but not in elaborator." CapTP's stream-level well-typedness is therefore the documented ceiling; per-exchange sub-protocols remain the workaround. #5 KEPT — `none`/`some` need explicit type args in some inference contexts. Real ergonomics tension, accurately documented. #6 DELETED — out-of-scope. WS-mode `let p := body` and sexp-mode `(let (p v) body)` are TWO surface forms by design (grammar.ebnf §7 line 1236). User-error, not a Prologos bug. #7 DELETED — was a quantitative restatement of #2. With #2 recanted, #7 evaporates: behavior modules can be wildcard-collapsed, dropping ~180 LOC. #8 DELETED — false claim. Tested: `data Box1 box1 : [Sigma [_ <Nat>] Bool]` and `data Table table : Nat -> [List [Sigma [_ <Nat>] Bool]]` both elaborate cleanly. The named-struct ActorEntry/PromiseEntry workaround in vat.prologos was unnecessary; can be simplified back. #9 DELETED — user error. `def` for value bindings vs `defn` for functions is documented (grammar.ebnf §3 lines 189-190, prologos-syntax rules). Mis-using `defn` for a 0-ary constant isn't a Prologos bug. #10 DELETED — out-of-scope. Network sandbox blocking external docs is an environment limitation. #11-#20 were not in scope of this review and remain as-is for the user to review next.
kumavis
pushed a commit
that referenced
this pull request
May 6, 2026
Per-track LOC contribution estimates for the remaining Phase 7 migration targets, with rationale + risk weighting + prerequisite ordering. Grounded against current code-size baselines: Zig kernel: 913 LOC Racket reducer + backends + bridge: 2347 LOC Summary (track / Zig delta / Racket delta / cb-time absorbed): #5 boolrec -> kernel_select +0 +30 ~4% (free; just routing) #4 ctor-N native ABI +400 +200/-100 ~5% workload, ~50% OCapN #3 expr-reduce match dispatch +200 +200/-150 ~10% #2 expr-natrec step +150 +50/-30 ~5% effective, ~17% theoretical #1 recursive expr-fvar + expr-app +1000 +400/-200 ~60% #7 CHAMP collection ops +5000+ +500/-200 ~4% (synthetic; defer) Net if #1-#5 land: Zig +1750 LOC (~3x growth); Racket -50 LOC net. Surface complexity migrates from Racket compile-expr to Zig kernel. Three suggested orderings (A: biggest payoff first; B: incremental; C: value-engineering minimum). All start with #5 (free), all prerequisite #4 before #3. Doc identifies 5 open design questions: ctor-N ABI choice (heap-backed vs bit-packed), closure representation, tail-call semantics, eager arm compilation interaction with recursion, bot-guard convention formalization. Three things this analysis does NOT settle: - Whether #1 is feasible without losing static-beta benefits (B1/B2/H1/J1/J2 do zero runtime fires today; native apply costs more rounds). - Per-fire cost of native call apparatus (somewhere between 115ns native and 4100ns callback; not measured). - Whether #1+#2+#3 land as one track or three (architecturally coupled; landing them independently means a stub-laden middle state). https://claude.ai/code/session_01Tycs6BWKG58Wo99YVPg6DF
hierophantos
added a commit
that referenced
this pull request
May 9, 2026
…sisted Phase 15 (Day's doubling / inflation detection per Adaricheva-Nation 2017) opens with full Stage 4 mini-design + mini-audit + adversarial CRITIQUE_METHODOLOGY pass. Background research (mempalace): Day's doubling lineage 1970-2017+. Day 1970 original interval-doubling (used to prove (W) for FL); 1979 bounded-homomorphic-image characterization; Adaricheva-Nation 2017 generalizes to all-or-nothing set inflation. Q1=B: Algorithm = Option B (Adaricheva-Nation 2017 all-or-nothing pair detection). Option A (Day covering-pair) subsumed. Q2=pair-only: extended-set search (Tier 4) deferred. Q3=no implication rule (sample-unsound either direction per Phase 12+13). Q4=full sweep scope (10 tuples; 4 domains × relations × depths). Q5=honest framing: sample-bounded admittance claim, not inflation history. Confirmation/refutation semantics differ from Phase 12+13: existence- claim shape — one witness = confirmed, none = refuted-on-sample. Adversarial pass: P/R/M/S two-column. 4 honest scope-acknowledgments; no drift requiring corrective. 7 drift risks named. Phase 15 = final reopened-arc phase. Track 2I closes after Phase 15. Adversarial VAG at close extends to whole reopened arc (Phases 11-15) per drift-risk #7.
hierophantos
added a commit
that referenced
this pull request
May 9, 2026
Sub-phase pattern not needed: single-commit implementation per Phase 11+ in-phase pattern. Algorithm: Option B (Adaricheva-Nation 2017 all-or-nothing pair detection). New code in sre-core.rkt: - dd-evidence 5-field struct (status × total-pairs × hypothesis-fired × conclusion-held × witness) - dd-classify-side helper: classifies external x w.r.t. (s1, s2) as 'above | 'below | 'incomparable | 'split - test-admits-day-doubling/detailed + wrapper. For each incomparable pair (s1, s2), check that no external x is 'split. First witness = confirmed; no witness = refuted-on-sample. - Wrapper coerces symbol-witness to list for axiom-refuted contract (refuted-on-sample uses 'no-incomparable-pairs / 'no-all-or-nothing- pair-on-sample markers). Wired into all 7 sites: provides + props-22 + evidence map + all-sweep-properties (now 20) + sweep dispatch + extract-detailed-fields (both sre-property-sweep and run-phase9-sweep per Phase 11 lesson). 7 new test-cases. Targeted suite GREEN: 196 tests / 4.5s. Sweep run via 4 concurrent processes (~1s wall total — much faster than estimated): | Tuple | Status | Non-vacuity | Witness highlight | |---|---|---|---| | type × eq × ground | refuted-on-sample | n/a | hash-code anomaly | | type × eq × wider | confirmed | 33% | (Int, pair(Bool, Bool)) | | type × sub × ground | refuted-on-sample | n/a | hash-code anomaly | | type × sub × wider | confirmed | 92% | (Bool, pair(Bool, Bool)) | | session × eq × ground | confirmed | 100% | (sess-end, sess-svar 0) | | session × eq × wider | confirmed | 100% | same | | form-cell × eq × ground/wider | confirmed | 40% | tag-set differing | | spec-cell × eq × ground/wider | confirmed | 33% | name differing | 8/10 tuples confirm Day-doubling admittance with concrete witnesses. Heterogeneous Prologos lattices universally admit Day-style inflation. Type × ground anomaly: nullary constructor instances (expr-Int, expr-Bool, etc.) have colliding equal-hash-codes, causing canonical- pair filter (< hash s1 hash s2) to skip same-hash pairs in BOTH directions. Atomic-pair incomparable-detection bypassed at ground sublattice. Wider sample provides substantive answer; documented as sample-set quirk in design doc tracker + Nation report § What we did not measure (already committed in f23ed5e). No forward implication rule (sample-unsound, Phase 12+13 precedent). test-sre-sd-properties.rkt:413 count: 19 → 20 (Phase 15 +1 admits-day-doubling). Adversarial VAG passed at phase close. Reopened-arc VAG (Phases 11-15 as unit) deferred to Track 2I close commit per drift-risk #7. Phase 15 — final reopened-arc phase. Track 2I close commit next.
hierophantos
added a commit
that referenced
this pull request
May 9, 2026
Track 2I substantively closed at Phase 10 (first close, 2026-05-08). Reopened for Phases 11-15 gap-closure (commit 6aab87c, same day). Phase 15 lands as the final reopened-arc phase. Reopened-arc adversarial VAG (Phases 11-15 as unit) per drift-risk #7: - (a) On-network: 5 new property checks extend Track 2G off-network scaffolding lineage; honestly labeled. - (b) Complete: 196 tests GREEN; substantive Q7 added to Nation report; honest scope-bounds (type×wider anti-exchange CPU timeout, type×ground all-or-nothing hash-collision artifact). - (c) Vision-advancing: empirical breadth across 5 algebraic axes; Adaricheva-Nation 2017 direct relevance secured for meeting. - (d) Drift-risks-cleared: each phase's named risks materialized as expected, didn't fire, or resolved in-flight. VAG passes adversarially across the reopened arc. Two cross-phase patterns surfaced for promotion candidate (next session's lessons-distillation pass): 1. No-forward-implication-rule discipline (sample-unsound) — 4-phase pattern across Phases 12, 13, 14, 15. 2. Single-commit code+sweep+report rhythm (Phase 11+ in-phase pattern) — 4 data points across Phases 11, 12, 13/14, 15. Track 2I final status: - 14 phases complete (1-15 minus Phase 9b sub-phasing) - 20 algebraic properties in all-sweep-properties - 4 SRE-registered domains × {ground, wider} sweep matrix populated - Lattice Variety Report ready for Nation meeting - 196 tests GREEN Open follow-ups (post-meeting): type×wider anti-exchange k=1 rerun; Phase 14 type-domain wider-sample congruence empirical content; Phase 15 extended-set search (Tier 4); property-cells migration (sister track); hash-code-stable canonicalization for atomic-struct samples. Track 2I CLOSED (substantively + comprehensively).
hierophantos
added a commit
that referenced
this pull request
Jul 1, 2026
…ir (LSP/REPL) A .prologos program's relative resource paths (read-file/read-csv) fell through to Racket's current-directory, so the same program worked under run-file.rkt (cwd = repo root) but DOUBLED the path under the VSCode/Emacs LSP/REPL (cwd = the file's dir). Modules already resolve location-independently against an absolute lib root (driver.rkt:143); resource files were the odd one out. Make resource paths source-file-relative (location-independent): - driver.rkt process-file: absolutize the path FIRST (so the source can be re-opened after re-anchoring), then parameterize current-directory to the source dir; add #:source-dir to override the anchor for callers that process a copy (the LSP diagnostics temp file). .pnet cache is already absolute, so unaffected. - lsp/server.rkt: diagnostics passes the real source dir via #:source-dir; the REPL loadFile path parameterizes current-directory from the doc URI (process-string-ws carries no path). New helper source-dir-of. - demo: use the sibling "deps.csv"; runs 0 errors from any cwd. - tests/test-relative-path-resolution.rkt: process-file from a foreign cwd resolves a relative read-file against the source dir (fails without the fix). Full suite 8387, all pass. Surfaced by the owner loading the demo in the LSP REPL (DEMO Track 1, design doc gap #7).
hierophantos
added a commit
that referenced
this pull request
Jul 23, 2026
…-network seed Rel T1 A.4 (guard) landed as DFS-routing (Check 4, commit 6b56397). Docs: - NEW BSP-LE Track 3 seed note (2026-07-20_BSP_LE_TRACK3_ONNET_SEED.md): the owner- requested implementation note documenting BOTH on-network seams Rel T1 hit and worked around — Issue 1 (A.2b: tabled rule generators incomplete via the body-local- var gap + tabling worldview-flattening) and Issue 2 (A.4: on-network guards' 3 bugs + the PROTOTYPED-AND-VERIFIED on-network guard mechanism: struct-resolution + per-binding belief-clear + a between-round handler). Linked from the BSP-LE Master + DEFERRED. - BSP-LE Master Track 3: add the A.4 guard retirement obligation + seed link. - Rel T1 design §5 A.4: reframed to LANDED (DFS-routing); the 3 guard bugs; the F2-is-a-crash premise refuted; the on-network mechanism deferred. Tracker A.4 → ✅; §11 A.4 resolved. - DEFERRED.md: A.4 guard DFS-routing scaffolding → Track 3. - Dailies: STATE head (HEAD 6b56397, suite 8934, Aspect-A COMPLETE) + A.4 LOG entry; Watching adds the WS-syntax probe lesson (one-line fact rows) + premise-refutation #7. - Rel Master: Track 1 Aspect-A COMPLETE; NEXT B/C/D + X.close (PIR).
hierophantos
added a commit
that referenced
this pull request
Jul 27, 2026
…correct 2 over-claims, retire 3 stale docs, file 7 deferrals
The X.close PIR-gathering workflow ran an adversarial test/doc-gap facet plus a
completeness critic (wf_8c22784b-3d8). Every finding below was R-lens-verified
in the main session before acting.
SHIPPED (was owed, still unshipped):
- **POL.1's ONLY deliverable.** POL.1 was ruled doc-only on 2026-07-24 ("bag
semantics stays; document it"), the POL row was marked ✅, and the doc line
was never written — `grep -rn "bag semantics"` across rules/spec/principles
was 0. Now in `.claude/rules/prologos-syntax.md`: solve returns one row per
DERIVATION PATH; duplicates are intended (ATMS-as-provenance / ℕ-semiring;
Prolog findall parity); do not "fix" them; `distinct` → Rel T2.
CORRECTED (my own over-claims — caught by the critic, verified, and wrong):
- **"acceptance ;;35-38" for POL.9a — markers 37 and 38 NEVER EXISTED.** The
file's markers run …35, 36, 39, 40. POL.9a added 34/35/36. The false range
appeared in the design doc, the dailies AND the commit message; the two
mutable copies are fixed and annotated (the commit message is immutable and
is called out here instead).
- **POL.9a "+13 tests" — actual +12** (58→70 test-case forms). Same three
places; same treatment.
CODE (comment-only, no behavior — but the track's own new rule red-flags it):
- `substitution.rkt:264` still carried `; Racket value, no de Bruijn vars` —
the FALSE assertion that made the SUB silent-wrong-answer bug look
intentional for months, and precisely the shape `pipeline.md § Exhaustive
Walkers` (added BY THIS TRACK) lists as a red flag. Replaced with the ruling
(D) contract, its by-construction justification (NbE opens binders, so
containers can only capture `#%nbe` fvars), and the pointer to the tripwire
that ENFORCES it. Verified: parens balanced, compiles, test-substitution +
test-rel-t1-pol 140/0.
STALE DOCS RETIRED:
- **`REL_MASTER.md` was stale by an entire track** — "newly opened; no tracks
locked" / "NEXT B/C/D" — and after the last sweep it CONTRADICTED the
roadmap. Now reflects all aspects delivered + the SUB spin-out + the PIR gate.
- **The seed note's `&>` label** — the exact item design §4 reserved for
X.close. `&>` is the rule-clause separator (Prolog `:-`), NOT a guard
operator with negation. Corrected in place with the full story: the owner's
instinct was right and the LOCATION was wrong; spelled correctly it hits the
real single-bit NAF collapse that Aspect A fixed. This is premise refutation
#1 of the track's cascade.
FILED (7 new DEFERRED entries, all verified):
- **POL.9: `not`/`=`/`is` do NOT take the implicit solve** (live-probed):
`(not (blocked "c"))` at top level is functional Bool negation of a stuck
goal term — 0 errors, useless answer. A real ergonomic hazard; three options
recorded, needs an owner ruling (it interacts with functional `not` on Bool).
Also documented as a warning in prologos-syntax.md.
- **The acceptance file has NO automated gate** (no test references it, no
golden, `compare-golden-for-file` has zero callers) + ~13/28 markers are
prose + **the POL cluster is Level-2 ONLY** (0 `process-file` vs 84
`run-ns-ws-last`), which testing.md mandates against for syntax features.
These compound: POL's L3 coverage rests entirely on an ungated file.
- **`current-relation-store` unthreaded** in test-support.rkt AND
batch-worker.rkt (0 hits each) — solve types as untyped, silently, in those
contexts. Instance #7 of the two-context class `pipeline.md` exists to
prevent; filed as an architectural signal, not a 7th individual fix.
- **SC (`19d9f8ae`) shipped a behavioral fix with zero tests** — the cited
"130 tests pass" is pre-existing regression evidence, not a pin.
- **POL.9 Q_D slice 2** (demand-loop retry) unimplemented and untracked while
the POL row reads ✅.
- **POL.8's merge FUTURE-TRAP** documented only in prose.
- **`docs/spec/grammar.ebnf` predates the whole POL cluster** and still
describes the dead-in-WS `?var:C1:C2` surface that now collides with C.b.1.
kumavis
pushed a commit
that referenced
this pull request
Jul 29, 2026
… red it exposed 9630 unit tests (clean cache), conformance 24/24. THE MODEL CHANGE `eff-connect` alone did not let the enlivener be an actor. Seeding it took the conformance suite 24 -> 23, because an enlivener CANNOT ANSWER and `ActStep` could not say so: the reply the peer waits for is a signed desc:handoff-give only the driver can build, but every ActStep carried a return value and `step-after-act` settled the answer promise with it unconditionally. The actor answered immediately with an echoed sturdyref where the peer expected a sig-envelope, and beat the real reply. `ActStep` now has a second outcome. `act-step-pending` acts without answering and leaves the promise pending. `syrup-null` was deliberately not used for this: `no-op` returns null and several behaviours rely on that settling their promise, so overloading it would have left those silently hanging. With both primitives the sturdyref enlivener is an ordinary actor at export 5, the driver intercepts NOTHING, and every op goes through `connection-step`. That closes §0.3 (export 5 had no actor) and half of §1.7 M8 (the Prologos side no longer double-processes; the Racket byte-scanners still do). THE CI RED, WHICH IS THE MORE USEFUL FINDING Widening `Vat` broke a bridge-test fixture that builds a vat AS A STRING, so it could not fail at compile time. It failed at elaboration inside `run-last`, reported as "could not infer type" with no mention of arity. Every local run passed. CI failed 3/164 on a fresh checkout. The difference was the `.pnet` cache: warm, it answered from the pre-change module and hid the fixture's staleness. `rm -rf data/cache/pnet` PLUS `rm -rf compiled/tests` reproduced CI exactly. This is the inverse of the lesson already in the document, where a stale cache CAUSED a spurious failure. It also hides real ones. A green local suite is not evidence after a type change; a green suite from a cold cache is. Recorded as newly-found #7. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01YM6gc3cMNH2Ymor4jdZY8u
kumavis
pushed a commit
that referenced
this pull request
Aug 3, 2026
`pipeline.md` § "New Racket Parameter" names those two files as items 2 and 3 of its checklist, and `grep -c current-relation-store` was 0 in both. So a `defr` registered by one call stayed visible to the next — and in a batch worker, to the next FILE — and `solve` in those contexts read a store that was not the ambient one, typing as untyped where production types. Silently, in both directions. The store is an immutable hasheq, so re-binding the ambient value per call and the post-prelude value per file is complete isolation: a `defr` inside builds a new store and cannot escape. Tests pin all three directions — nothing leaks forward, the caller's binding survives a call, and register-then-query within ONE call still works. The third matters: isolation that breaks the ordinary case is not isolation. 2 of the 3 fail against the previous commit. The entry's framing stands and I have not addressed it: this class recurs because the parameter set is discovered by grep rather than declared in one place, and that is still open. What changes is that instance #7 is no longer silently live while the general answer is designed. The same session closed the cell-backed half of this identical class (the cross-file spec-store leak). Two instances of one boundary, both live, reached from opposite directions — one by bisecting a flake, one by reading the entry. Suite 10174/526 green, conformance 24/24. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01YM6gc3cMNH2Ymor4jdZY8u
hierophantos
added a commit
that referenced
this pull request
Aug 14, 2026
…peated the class it was fixing — derived from ONE example, backwards about its own rule, and pinned by a test that was vacuous from birth Round 3 (`wf_1bb04012-af2`, 4 lenses + adjudicator): 14 raw → 9 survivors, 5 killed or merged by the adjudicator's own re-runs. Every finding below was re-measured on the main thread before acting. Nothing in rounds 1–2 produced a wrong answer; all survivors are diagnostic, instrument or record defects. ⭐⭐ #1 (MAJOR) — THE ROUND-2 REWRITE OF `star-l4-mixed` WAS ITSELF DERIVED FROM ONE POPULATION. In its driving example the STAR branch happened to be the keyless one, so both remedies were written as things to do to a SIBLING. Outside that example they are non-actions, measured: pc{db.hosts* ports*} → the error BYTE-IDENTICAL (starring a sibling that keeps no key changes nothing) pc{db.hosts* ports^^} → parse error, "one `^` per segment" d3{a* x^.y.z*} → byte-identical to d3{a* x.y.z*} — one caret is not enough at depth 3 and the action that DOES work was never named, because it is on the star branch: pc{db^.hosts* ports^} → @[@[1 2] @[80]] ✓ d3{a* x^.y^.z*} → @[@[1 2] @[5 6]] ✓ The message now states Q_U47's REMAINDER rule and lets the action follow from it — dissolve the surviving key on WHICHEVER branch keeps one, including the star branch itself, one per surviving level — instead of enumerating spellings that hold for one shape. "Select the flatten in its own block" was the only clause that was an action in every population measured; it stays, marked as such. ⭐⭐ #5 (MINOR, but it is why #1 was invisible) — THE RULE WAS STATED BACKWARDS. It said a star lands keyless "when no step survives AFTER it". `*` is branch-FINAL (`e3{a*.p}` → "`*` is only supported at the END of a branch"), so that condition is VACUOUSLY TRUE and the sentence asserts every star lands keyless — while `e3{a.b.c*}` → `{:a {:b @[1 2]}}` lands KEYED. The sibling message written in the SAME commit had it right ("the steps BEFORE the star"). Two messages, one rule, opposite directions, and the battery pinned the wrong one. ⭐⭐ #2 (MAJOR) — AND THE PIN THAT SHOULD HAVE CAUGHT #1 WAS VACUOUS FROM BIRTH (`d8776b66`). `C2V`'s `cfg` is `{:db {:hosts … :ports …}}`, so `:ports` lives UNDER `:db` and `cfg{db.hosts* ports^}` died at field resolution ("field :ports is not present … available fields: :db"), never reaching the L4 seat. Its `c2-refused?` half is #t for that unrelated error and its `check-false` matched nothing — both halves green on a failure that was not the one under test. That is precisely why the round-2 rewrite could specialise to the wrong population with nothing to contradict it. Fixed with a subject whose keyless sibling is genuinely top-level, plus the POSITIVE half the file's own `c2-refused?` header already demands: assert WHICH gate refused. #8 (MINOR) — "sub-block grouping does NOT survive a star" was an overclaim. Measured, it survives when EVERY grouped branch is starred (`cfg{db.{hosts* ports*}}` → `{:db @[@[1 2] @[80]]}`, 0 errors); what breaks it is starring some but not all — Q_U47 again. Claim narrowed and BOTH spellings pinned, so a future session trying the natural all-starred form finds the record already knows about it instead of concluding the comment is wrong. #7 (MINOR) — the round-2 pins under-discriminated: bare `c2-refused?` negatives that pass on any error (the #2 class), and a `^k'` regex already green before "EITHER branch" was added. Each refusal now asserts which gate produced it. #3 + #9 — DEFERRED 123 corrected on two points, both mine. It is LIVE, not a latent quality risk: `rec3{a.b a^r.b.zzz}` reports ``(branch `a.b`)`` while `rec3{a.b}` alone SUCCEEDS, so the message names a valid sibling that did not fail. And there is a SECOND collapse channel the diagnosis never named — the ω marker (`rowz{k:s.zzz}` → ``(branch `k.s`)``, and `k.s` fails one step earlier, so it is not merely a different spelling). The repair scope also charged for a "reduction twin" that DOES NOT EXIST: reduction has 0 `append path` and 0 `select-fail` sites and threads no path at all. That stale clause read as an ATOMIC co-migration obligation and would have sent the next session hunting for a seat that isn't there — it survived a whole verify round because pins assert kinds and code, never prose. NOT charged to this commit, reported by round 3 and left where they belong: · DEFERRED 117 reproduces at HEAD and its exposure is understated — `mx{z a^.{c*}}` is a WHOLE-FILE ABORT (`symbol<?: contract violation`, no output at all) and the branch-swapped order silently drops a key at 0 errors, while the un-nested spelling refuses correctly in both orders. Pre-existing; the deliberate "widen both gates in one edit" deferral still stands. · LATENT: typing's `select-step-name` `[else s]` renders a raw IR step list into a user-facing message for a `(@sub …)` head, and syntax.rkt's comment above it asserts that cannot happen. Reachable only as constructed IR — the parser seals all four follower bands. Gate: battery 520 → 521, 0 FAILURE / 0 ERROR, exit 0, full output size · mutation-tested in place (round-2 wording restored → exactly the two new R3 pins redden) · acceptance 89 markers, 0 errors · neighbourhood 4/4, 122 tests. ⚠ The first cut of two pins compared FULL rendered lines, which end with the source expression — so byte-identical messages could never compare equal and the pin went red for its own construction, not for behaviour. They compare the message body now.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Companion to the 2026-04-23 eigentrust pitfalls memo. The four items in this PR are observations (not Prologos defects) that should be tracked separately from the bug-fix PRs so a future reader does not double-count them as open work.
Coverage
~literal prefix is unambiguous unlike0/1. No action needed.Mdirectly and validates viacol-stochastic?.Test plan
PR map across the pitfalls
claude/fix-eigentrust-pitfall-3-rl3zclaude/fix-eigentrust-pitfall-5-letmclaude/fix-eigentrust-pitfall-6-m5bE8claude/fix-eigentrust-observations-docclaude/fix-eigentrust-observations-docclaude/fix-eigentrust-observations-docclaude/fix-eigentrust-pitfall-12-pv12claude/fix-eigentrust-pitfall-13-pv13claude/fix-eigentrust-pitfall-14-pp01claude/fix-eigentrust-pitfall-15-mldefclaude/fix-eigentrust-observations-dochttps://claude.ai/code/session_01MbncYJnrvjzhbVWw4xGi5x
Generated by Claude Code