From c62cb3f9ef44bfb1b9d0a72fd0a72dcf5b431be7 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 4 Jul 2026 09:50:39 +0000 Subject: [PATCH] =?UTF-8?q?examples:=20motion=20=3D=20bit=20shift=20=C3=97?= =?UTF-8?q?=20transform=20no-op=20=C3=97=20shaping=20=E2=80=94=20measured?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The operator's factorization of M1: motion compensation in this substrate is bit shift (integer motion = addressing, zero arithmetic — the deterministic PLACE / VPGATHERDD) × transform no-op (the DCT a real codec puts after MC collapses to identity when prediction is good) × shaping (the residue applied directly as a shape, not transform-coded). M1 already IS this: recon = shifted_ref + residual, no transform, and 62.5% of blocks had residual == 0 (transform fully absent). This probe MEASURES the factorization as a tradeoff curve. All three codings are orthonormal (equal PSNR at a fixed quant step Q); bytes = order-0 Shannon entropy (ideal rANS). Residual lag-1 autocorrelation ρ is the motion-quality proxy (good motion → white residual → ρ→0), because a transform cannot compress white noise. Measured (128x128, 8x8 blocks, Q=6): residual ρ(meas) direct wht dct dct/dir wht/dct ρ≈0.00 -0.001 9135 9579 9581 0.95x 1.00x ρ≈0.30 0.053 8386 8609 8608 0.97x 1.00x ρ≈0.60 0.419 7664 7147 7146 1.07x 1.00x ρ≈0.90 0.961 7641 3846 3754 2.04x 1.02x Both falsifiable claims hold: 1. transform no-op grows with motion quality — dct/dir → 1 (even below, 0.95x) as the residual whitens; the transform is a literal no-op in the good-motion regime and only earns its keep (2.04x) on structured residuals (poor motion), the regime good bit-shift avoids. The transform's value is inversely coupled to motion quality. 2. a multiply-free sign transform suffices — wht/dct ≈ 1.00–1.02x across the whole sweep. The ±1 add/subtract Walsh–Hadamard transform (the shader's "zero FP, zero matmul" idiom) matches the full multiply DCT within 2%, even where the transform matters most. The substrate never needs a DCT. So motion = bit shift (free) × transform no-op (WHT, vanishing as motion improves) × shaping (direct residue) — one tradeoff curve, not three stages. Ties to H-7 via the residue CellMode histogram. fmt + clippy clean, gated. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_01MLBnPuScZy6w9di2QEjsXM --- Cargo.toml | 4 + examples/motion_transform_noop.rs | 311 ++++++++++++++++++++++++++++++ 2 files changed, 315 insertions(+) create mode 100644 examples/motion_transform_noop.rs diff --git a/Cargo.toml b/Cargo.toml index 3a38cf45..44f8aa02 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -91,6 +91,10 @@ required-features = ["codec"] name = "residue_upscale" required-features = ["codec"] +[[example]] +name = "motion_transform_noop" +required-features = ["codec"] + [[example]] name = "entropy_ladder_probe" required-features = ["std"] diff --git a/examples/motion_transform_noop.rs b/examples/motion_transform_noop.rs new file mode 100644 index 00000000..e839c225 --- /dev/null +++ b/examples/motion_transform_noop.rs @@ -0,0 +1,311 @@ +//! Motion = bit shift × transform no-op × shaping — the measured factorization. +//! +//! The operator's reframe (2026-07-04): motion compensation in this substrate +//! factors as **bit shift** (integer motion = addressing, zero arithmetic — the +//! deterministic PLACE / `VPGATHERDD`) × **transform no-op** (the DCT stage a +//! real codec puts after MC collapses to identity when prediction is good) × +//! **shaping** (the residue applied directly, coded as a shape — not +//! transform-coded). M1 already IS this: `recon = shifted_ref + residual`, no +//! transform; and M1 measured 62.5% of blocks with residual == 0 (transform +//! fully absent — pure bit shift). +//! +//! The factorization is a **tradeoff curve, not three stages**: better bit-shift +//! ⇒ whiter residual ⇒ the transform has less to compact ⇒ shaping is trivial. +//! This probe MEASURES that curve, because a transform CANNOT compress white +//! noise (its coding gain → 1). The falsifiable claims: +//! +//! 1. **transform no-op grows with motion quality** — the DCT's byte advantage +//! over *direct* shaping (no transform) → 1 as the residual whitens +//! (i.e. as motion improves). When it hits 1, the transform is a literal +//! no-op and can be dropped. +//! 2. **a multiply-free sign transform suffices** — the Walsh–Hadamard +//! transform (±1 basis, add/subtract only — the shader's "zero FP, zero +//! matmul" idiom) tracks the DCT within a few %, so the substrate never +//! needs a multiply-based DCT. WHT is the honest "transform" for a codec +//! that IS the zero-FP cognitive shader. +//! +//! # Fairness +//! +//! All three transforms are **orthonormal**, so quantising coefficients with the +//! same step `Q` yields the same L2 distortion (Parseval) — an equal-PSNR byte +//! comparison. Bytes = order-0 Shannon entropy `H₀` of the quantised symbols +//! (what an ideal rANS coder spends). "direct" = quantise the residual in the +//! spatial domain (no transform = pure shaping); "wht"/"dct" = transform, then +//! quantise the coefficients. +//! +//! Residual correlation `ρ` (lag-1 autocorrelation) is the stand-in for motion +//! quality: good motion ⇒ white residual (`ρ → 0`); poor motion ⇒ structured +//! residual (`ρ → 1`). This is the textbook "MC decorrelates, leaving a +//! near-white residual" — here quantified on the substrate. +//! +//! Run: `cargo run --release --example motion_transform_noop --features codec` + +use ndarray::hpc::codec::CellMode; + +const W: usize = 128; +const H: usize = 128; +const B: usize = 8; // transform block edge (8×8), B = 2³ for the fast WHT +const K: usize = B * B; +const BX: usize = W / B; +const BY: usize = H / B; +const Q: f64 = 6.0; // quantisation step (same for all three → equal PSNR) + +fn mix(mut z: u64) -> u64 { + z = z.wrapping_add(0x9E37_79B9_7F4A_7C15); + z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + z ^ (z >> 31) +} + +/// A residual field at controlled lag-1 correlation `rho` — a blend of a smooth +/// (correlated) component and white noise. `rho ≈ 0` = white (good motion); +/// `rho ≈ 1` = structured (poor motion). Zero-mean. +fn residual_field(rho: f64) -> Vec { + let mut f = vec![0.0f64; W * H]; + for y in 0..H { + for x in 0..W { + let (xf, yf) = (x as f64, y as f64); + let smooth = 40.0 * (xf * 0.05).sin() * (yf * 0.045).cos() + 20.0 * (yf * 0.03).sin(); + let white = ((mix((y as u64) << 20 | x as u64) & 0xFF) as f64) - 127.5; + f[y * W + x] = rho * smooth + (1.0 - rho) * (white * 0.5); + } + } + f +} + +/// Measured lag-1 autocorrelation (horizontal + vertical averaged) — the honest +/// whiteness readout, independent of the `rho` knob. +fn autocorr_lag1(f: &[f64]) -> f64 { + let mean = f.iter().sum::() / f.len() as f64; + let var = f.iter().map(|&v| (v - mean) * (v - mean)).sum::() / f.len() as f64; + if var < 1e-12 { + return 0.0; + } + let mut cov = 0.0; + let mut n = 0.0; + for y in 0..H { + for x in 0..W { + if x + 1 < W { + cov += (f[y * W + x] - mean) * (f[y * W + x + 1] - mean); + n += 1.0; + } + if y + 1 < H { + cov += (f[y * W + x] - mean) * (f[(y + 1) * W + x] - mean); + n += 1.0; + } + } + } + (cov / n) / var +} + +/// Orthonormal 8-point DCT-II basis row `k`. +fn dct_row(k: usize) -> [f64; B] { + let mut r = [0.0f64; B]; + let alpha = if k == 0 { + (1.0 / B as f64).sqrt() + } else { + (2.0 / B as f64).sqrt() + }; + for (n, rn) in r.iter_mut().enumerate() { + *rn = alpha * (std::f64::consts::PI * (2.0 * n as f64 + 1.0) * k as f64 / (2.0 * B as f64)).cos(); + } + r +} + +/// 2-D separable orthonormal DCT-II of an 8×8 block (full multiplies). +fn dct2(block: &[f64; K]) -> [f64; K] { + let basis: Vec<[f64; B]> = (0..B).map(dct_row).collect(); + // rows + let mut tmp = [0.0f64; K]; + for r in 0..B { + for k in 0..B { + let mut s = 0.0; + for n in 0..B { + s += basis[k][n] * block[r * B + n]; + } + tmp[r * B + k] = s; + } + } + // cols + let mut out = [0.0f64; K]; + for c in 0..B { + for k in 0..B { + let mut s = 0.0; + for n in 0..B { + s += basis[k][n] * tmp[n * B + c]; + } + out[k * B + c] = s; + } + } + out +} + +/// 2-D separable orthonormal Walsh–Hadamard transform of an 8×8 block. The basis +/// is ±1/√8 — the transform is pure add/subtract (a sign transform), ZERO +/// multiplies in the butterfly. This is the codec transform that matches the +/// "zero FP, zero matmul" cognitive shader. (Multiplies here are only the final +/// 1/√8 normalisation, foldable into the quant step.) +fn wht2(block: &[f64; K]) -> [f64; K] { + let mut m = *block; + let scale = 1.0 / (B as f64).sqrt(); + // rows: in-place fast WHT (add/subtract butterfly), then normalise + for r in 0..B { + fwht(&mut m[r * B..r * B + B]); + } + // cols + let mut col = [0.0f64; B]; + for c in 0..B { + for r in 0..B { + col[r] = m[r * B + c]; + } + fwht(&mut col); + for r in 0..B { + m[r * B + c] = col[r] * scale * scale; + } + } + m +} + +/// In-place fast Walsh–Hadamard transform (natural order), length 8 = 2³. +/// Add/subtract butterflies only — no multiplies. +fn fwht(a: &mut [f64]) { + let n = a.len(); + let mut h = 1; + while h < n { + let mut i = 0; + while i < n { + for j in i..i + h { + let (x, y) = (a[j], a[j + h]); + a[j] = x + y; + a[j + h] = x - y; + } + i += 2 * h; + } + h *= 2; + } +} + +/// Order-0 Shannon entropy of an integer symbol stream, in bytes. +fn entropy_bytes(sym: &[i64]) -> f64 { + use std::collections::HashMap; + let mut hist: HashMap = HashMap::new(); + for &s in sym { + *hist.entry(s).or_insert(0) += 1; + } + let n = sym.len() as f64; + let bits: f64 = hist + .values() + .map(|&c| { + let p = c as f64 / n; + -(c as f64) * p.log2() + }) + .sum(); + bits / 8.0 +} + +/// Quantise a coefficient/sample to the nearest multiple of `Q` → integer symbol. +fn quant(v: f64) -> i64 { + (v / Q).round() as i64 +} + +fn main() { + let block_at = |f: &[f64], bx: usize, by: usize| -> [f64; K] { + let mut blk = [0.0f64; K]; + for j in 0..B { + for i in 0..B { + blk[j * B + i] = f[(by * B + j) * W + (bx * B + i)]; + } + } + blk + }; + + println!("Motion = bit shift × transform no-op × shaping — measured"); + println!(" {W}×{H}, {B}×{B} blocks, Q={Q} (orthonormal ⇒ equal PSNR); bytes = H₀ (ideal rANS)"); + println!(" ρ = residual lag-1 autocorrelation (motion quality proxy: ρ→0 = good motion)\n"); + println!( + " {:<10} {:>7} {:>10} {:>10} {:>10} {:>8} {:>8}", + "residual", "ρ", "direct", "wht", "dct", "dct/dir", "wht/dct" + ); + + for &rho in &[0.0, 0.3, 0.6, 0.9] { + let f = residual_field(rho); + let rho_meas = autocorr_lag1(&f); + + let (mut direct, mut wht, mut dct) = (Vec::new(), Vec::new(), Vec::new()); + for by in 0..BY { + for bx in 0..BX { + let blk = block_at(&f, bx, by); + // direct = pure shaping (quantise spatial residual, no transform) + for &v in &blk { + direct.push(quant(v)); + } + // wht = multiply-free sign transform + for &v in &wht2(&blk) { + wht.push(quant(v)); + } + // dct = full multiply transform + for &v in &dct2(&blk) { + dct.push(quant(v)); + } + } + } + let (db, wb, cb) = (entropy_bytes(&direct), entropy_bytes(&wht), entropy_bytes(&dct)); + println!( + " ρ≈{:<7.2} {:>7.3} {:>10.0} {:>10.0} {:>10.0} {:>7.2}× {:>7.2}×", + rho, + rho_meas, + db, + wb, + cb, + db / cb, // transform's advantage over direct shaping (>1 ⇒ transform earns keep) + wb / cb, // multiply-free vs full transform (≈1 ⇒ WHT suffices) + ); + } + + // H-7 tie-in: for the white residual (good motion), how many transform coeffs + // survive quantisation? Near-white ⇒ energy spread ⇒ few zeros; the point is + // the transform buys nothing there (dct/dir ≈ 1 above), so the CellMode of the + // *direct* residue is what the codec actually stores. + let fw = residual_field(0.0); + let mut modes = [0usize; 3]; + for by in 0..BY { + for bx in 0..BX { + for &v in &block_at(&fw, bx, by) { + let q = quant(v); + let mode = if q == 0 { + CellMode::Skip + } else if q.abs() <= 127 { + CellMode::Delta + } else { + CellMode::Escape + }; + modes[match mode { + CellMode::Skip => 0, + CellMode::Delta => 1, + _ => 2, + }] += 1; + } + } + } + println!( + "\n [H-7] white-residual (good motion) direct CellMode: skip={} delta={} escape={}", + modes[0], modes[1], modes[2] + ); + + println!( + "\n MEASURED CONCLUSION:\n\ + \x20 • dct/dir is the transform's byte advantage over direct shaping. As the\n\ + \x20 residual whitens (ρ→0, i.e. motion improves) it approaches 1 — the\n\ + \x20 transform becomes a literal NO-OP and can be dropped. It only earns its\n\ + \x20 keep on structured residuals (ρ high = poor motion), the regime good\n\ + \x20 bit-shift motion avoids. This IS 'transform no-op': the transform's\n\ + \x20 value is inversely coupled to the motion's quality.\n\ + \x20 • wht/dct ≈ 1 across the sweep — the multiply-free ±1 sign transform\n\ + \x20 (add/subtract only, the shader's zero-FP idiom) matches the full DCT.\n\ + \x20 The substrate never needs a multiply-based DCT; WHT is the codec\n\ + \x20 transform that IS the cognitive shader.\n\ + \x20 • So: motion = bit shift (free addressing) × transform no-op (WHT, and\n\ + \x20 vanishing as motion improves) × shaping (the direct residue). The three\n\ + \x20 factors are one tradeoff curve, not three independent stages." + ); +}