From f8950beee291366d57c32a13c1e4b5d79d71a489 Mon Sep 17 00:00:00 2001 From: Allaun Silverfox <28494262+allaunthefox@users.noreply.github.com> Date: Tue, 23 Jun 2026 05:00:59 -0500 Subject: [PATCH] docs(triage): ASCII triage diagram --- docs/adversarial_review/TRIAGE_DIAGRAM.md | 150 ++++++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 docs/adversarial_review/TRIAGE_DIAGRAM.md diff --git a/docs/adversarial_review/TRIAGE_DIAGRAM.md b/docs/adversarial_review/TRIAGE_DIAGRAM.md new file mode 100644 index 00000000..3db7591e --- /dev/null +++ b/docs/adversarial_review/TRIAGE_DIAGRAM.md @@ -0,0 +1,150 @@ +# SILVERSIGHT TRIAGE DIAGRAM +## The Flagship is Dead — What's Salvageable? + +``` + SILVERSIGHT PROJECT + ═══════════════════════════ + + ┌─────────────────┐ + │ CHENTSOV THM │ + │ ☠️ DEAD ☠️ │ + │ rfl ≠ proof │ + └────────┬────────┘ + │FOUNDATION GAP + │(all downstream claims tainted) + ┌───────────────┼───────────────┐ + ▼ ▼ ▼ + ┌──────────┐ ┌──────────────┐ ┌──────────┐ + │ Chentsov │ │ NP-hard sort │ │ Finsler │ + │uniqueness│ │ smuggling │ │ metric │ + │ ☠️ │ │ ☠️ │ │ ☠️ │ + └──────────┘ └──────────────┘ └──────────┘ + ▼ ▼ ▼ + [NOT PROVEN] [NOT POSSIBLE] [NOT A METRIC] + +═══════════════════════════════════════════════════════════════════════ + THE TRIAGE CUT +═══════════════════════════════════════════════════════════════════════ + + KEEP (PROVEN) FIX (CONDITIONAL) KILL (UNPROVEN) + ═══════════════ ═══════════════════ ═══════════════ + + ✅ SidonSets 🟡 Chentsov* ❌ Chentsov claim + (Lindström, [RESTATE as: "Fisher ❌ NP-hard solving + Johnson bounds metric is invariant ❌ Finsler metric + — real math) under splittings"] + + note: uniqueness ❌ Full PVGS bridge + ✅ HachimojiCodec is OPEN PROBLEM ❌ 7 axioms (conjecture + (consistency theorems markers only) + — honestly proven) 🟡 Eigensolid + [RESTATE as: verified- ❌ Receipt bijection + ✅ SilverSightCore by-computation, not (tautology) + (AVM theorems — convergence theorem] + induction, real) ❌ Spectral profile + (trivial collisions) + ✅ eigensolid_trivial 🟡 Resumable DAG + (conditional, real [RESTATE as: heuristic ❌ SQL injection + proof under non- chunking strategy, (security flaw) + saturation) not complexity result] + + ✅ Φ-corkscrew 🟡 Φ-corkscrew + (bijection valid — [FORMALIZE in Lean — ❌ Receipt forgeability + irrational rotation open goal, but valid (zero auth) + is sound) math] + + ✅ Golden spiral 🟡 Q16_16 arithmetic + (exact roundtrip) [UNIFY to single impl ❌ DNA encoding + (fully reversible) + ✅ 4-mode agreement 🟡 Test coverage + (CV=0.0 verified) [80%+ critical paths] ❌ Unbounded 2**n + enumeration + ✅ Integration sprint 🟡 WGSL shaders + (28/28 checks pass, [add barriers] ❌ Chaos game LCG + receipts match) (predictable) + +═══════════════════════════════════════════════════════════════════════ + PRIORITY ORDER +═══════════════════════════════════════════════════════════════════════ + + P0 — SECURITY (do FIRST, block everything else) + ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + [1] Fix SQL injection (hachimoji_citation.py) + [2] Fix receipt forgeability (add HMAC-SHA256) + [3] Bounds-check all 2**n enumerations + [4] Fix WGSL buffer overflow (unbounded indexing) + + P1 — FOUNDATION (do NEXT, everything depends on this) + ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + [5] Unify Q16_16 arithmetic (single canonical impl) + [6] Restate Chentsov theorem to what IS proven + [7] Mark 7 axioms as CONJECTURES, not axioms + [8] Fix Finsler metric or rename to "distance-like function" + + P2 — QUALITY (do AFTER foundation is solid) + ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + [9] 80%+ test coverage for critical paths + [10] End-to-end integration test + [11] Fix spectral profile collisions (add semantic features) + [12] Add keyed layer to DNA encoding (optional encryption) + + P3 — FORMALIZATION (do WHEN P0-P2 done) + ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + [13] Formalize Φ-corkscrew bijection in Lean + [14] Replace native_decide proofs with real proofs + [15] Close 23 sorries (priority order) + [16] Prove eigensolid convergence by induction + +═══════════════════════════════════════════════════════════════════════ + SALVAGED CORE +═══════════════════════════════════════════════════════════════════════ + + What SilverSight ACTUALLY is (after triage): + + ┌─────────────────────────────────────────────────────────────────┐ + │ │ + │ A deterministic equation classifier using: │ + │ • Chaos game on the probability simplex (Δ₇) │ + │ • Byte-level co-occurrence spectral profiles │ + │ • Q16_16 fixed-point arithmetic throughout │ + │ • 8-strand braid eigensolid compression (conditional) │ + │ • Φ-corkscrew bijective state encoding │ + │ • Multi-mode execution (ESP32/photonic/quantum/tensor) │ + │ │ + │ Claims NO LONGER MADE: │ + │ ✗ "Unique Fisher metric by Chentsov" → "Fisher metric is │ + │ invariant under splittings; uniqueness is open" │ + │ ✗ "Solves NP-hard problems" → "Heuristic chunking for │ + │ large-scale tensor network contraction" │ + │ ✗ "Finsler metric for QUBO" → "Distance-like function │ + │ inspired by Randers geometry" │ + │ ✗ "Receipts are proofs" → "Receipts are signed measurements" │ + │ │ + └─────────────────────────────────────────────────────────────────┘ + +═══════════════════════════════════════════════════════════════════════ + EFFORT ESTIMATE +═══════════════════════════════════════════════════════════════════════ + + P0 (security): ~2 days → blocks everything + P1 (foundation): ~1 week → redefines the project + P2 (quality): ~2 weeks → production-ready code + P3 (formal): ~3 months → genuine theorem library + + Total to production-ready: ~3 weeks + Total to theorem library: ~4 months + +═══════════════════════════════════════════════════════════════════════ + THE BOTTOM LINE +═══════════════════════════════════════════════════════════════════════ + + The project is NOT "mathematical marshmallow fluff." It contains + genuine proven results (Sidon sets, codec consistency, AVM core, + eigensolid conditional theorem) and a solid engineering pipeline + (4-mode agreement, Φ-corkscrew, integration sprint). + + What it IS: a good engineering prototype with overambitious + mathematical marketing. The math that works WORKS. The math that + doesn't work needs to be honestly restated. + + → Strip the false claims → Keep the proven core → Build honestly. +```