test(pal256): 64-hop numerical containment vs epistemic hallucination falsifiers

.claude/board/entries/2026-10-22-pal256-64hop-error-containment.md

@@ -0,0 +1,9 @@
+# Palette256: 64-hop containment is a falsifiable hypothesis, not a hallucination guarantee
+
+Existing reference surfaces: `bgz-tensor::fisher_z::FisherZTable` immutable family LUT; `ndarray::hpc` statistical moments; `lance-graph-nal` evidence-source stamping; Math Foundry cold proof/extraction. No rewriting of these engines.
+
+Test 1: repeated lookup by stable references has no *repeated encode/decode*. Test 2: a **specified** contraction (`L=0.7`) with a bounded rounding term satisfies a 64-hop numerical envelope. Negative control: a bounded but expansive recurrence grows a false belief; 32 derived paths from one root are still one independent source.
+
+Next experiment must use real `FisherZTable` pairwise score compositions, 1/2/4/8/16/32/64 hops, exact f64 oracle, held-out path labels, source disjointness, min-max/mean/p95/p99 numerical error, calibration, false-positive and abstention rates, performance and adversarial correlated roots. Count sample size per *independent original observation*. A rho 0.9998 on 2000 single pairs proves neither 64-hop rank preservation nor semantic validity.
+
+Run: `cargo test --manifest-path crates/bgz-tensor/Cargo.toml --test palette256_multihop_error_probe`.

.claude/board/entries/README.md

@@ -25,7 +25,7 @@ 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.
 
-436 entries, 2026-08-06 .. 2026-10-22.
+438 entries, 2026-08-06 .. 2026-10-22.
 
 | date | entry id | finding | file |
 |---|---|---|---|
@@ -34,6 +34,7 @@ exactly one of them, never both.
 | 2026-10-22 | `pal256-immutable-needle-distribution-probe` |  | [2026-10-22-pal256-immutable-needle-distribution-probe.md](2026-10-22-pal256-immutable-needle-distribution-probe.md) |
 | 2026-10-22 | `pal256-hebbian-overlay-plasticity` |  | [2026-10-22-pal256-hebbian-overlay-plasticity.md](2026-10-22-pal256-hebbian-overlay-plasticity.md) |
 | 2026-10-22 | `pal256-argextrema-margins` |  | [2026-10-22-pal256-argextrema-margins.md](2026-10-22-pal256-argextrema-margins.md) |
+| 2026-10-22 | `pal256-64hop-error-containment` |  | [2026-10-22-pal256-64hop-error-containment.md](2026-10-22-pal256-64hop-error-containment.md) |
 | 2026-10-22 | `pal256-3sigma-statistical-gate` |  | [2026-10-22-pal256-3sigma-statistical-gate.md](2026-10-22-pal256-3sigma-statistical-gate.md) |
 | 2026-10-22 | `math-compiler-stage-b-e1` |  | [2026-10-22-math-compiler-stage-b-e1.md](2026-10-22-math-compiler-stage-b-e1.md) |
 | 2026-10-22 | `math-compiler-gap-matrix` |  | [2026-10-22-math-compiler-gap-matrix.md](2026-10-22-math-compiler-gap-matrix.md) |

crates/bgz-tensor/tests/palette256_multihop_error_probe.rs

@@ -0,0 +1,49 @@
+//! Distinguish four claims: frozen lookup (no re-encode), quantized contraction,
+//! shared-source false precision, and semantic correctness. Only the first two
+//! have numerical properties; bounded outputs do not certify factual truth.
+fn q8(x: f64) -> f64 {
+    (x.clamp(-1.0, 1.0) * 127.0).round() / 127.0
+}
+#[test]
+fn stable_lookup_of_immutable_values_does_not_requantize_per_hop() {
+    const PAIRS: [[i8; 3]; 3] = [[127, 64, -40], [33, 127, 10], [-55, 15, 127]];
+    let original = PAIRS;
+    let mut address = 0_usize;
+    for _ in 0..64 {
+        let next = (address + 1) % 3;
+        let relation = PAIRS[address][next];
+        assert_eq!(relation, original[address][next]);
+        address = next; // traverse addresses; never feed a decoded score into bake
+    }
+    assert_eq!(PAIRS, original);
+}
+#[test]
+fn contractive_quantized_recursion_has_a_measurable_64hop_bound() {
+    let (mut exact, mut quantized) = (0.25_f64, 0.25_f64);
+    let lipschitz = 0.7_f64;
+    let one_step_rounding = 0.5 / 127.0 + 1e-12;
+    for hop in 1..=64 {
+        exact = lipschitz * exact + 0.08;
+        quantized = q8(lipschitz * quantized + 0.08);
+        let envelope = one_step_rounding * (1.0 - lipschitz.powi(hop)) / (1.0 - lipschitz);
+        assert!((exact - quantized).abs() <= envelope + 1e-12);
+    }
+}
+#[test]
+fn saturation_and_duplicate_paths_can_preserve_an_unsupported_claim() {
+    let mut spurious_score = 0.01_f64;
+    for _ in 0..16 {
+        spurious_score = (1.5 * spurious_score).clamp(-1.0, 1.0);
+    }
+    assert!(
+        spurious_score > 0.5,
+        "finite range alone does NOT prevent reinforcement"
+    );
+    let shared_root = 1_u64 << 7;
+    let paths = [shared_root; 32];
+    let distinct = paths.iter().copied().fold(0u64, |a, b| a | b).count_ones();
+    assert_eq!(
+        distinct, 1,
+        "32 derived paths are one independent observation"
+    );
+}