test: pin real predictor fixture (#198)

Author: adrienlacombe

crates/pwm-testkit/fixtures/README.md

@@ -0,0 +1,30 @@
+# pwm-testkit fixtures
+
+## `lewm_predictor_real_compact.json`
+
+Compact real-checkpoint predictor regression fixture for issue #178.
+
+- Checkpoint: `quentinll/lewm-pusht` `weights.pt`, revision
+  `22b330c28c27ead4bfd1888615af1340e3fe9052`, SHA-256
+  `48938400ae3464c9680731287f583a9cb516f55a8ec64ea13a91be47fb15b607`,
+  MIT license.
+- Input episode: `lerobot/pusht`, revision
+  `7628202a2180972f291ba1bc6723834921e72c19`, episode `0`, frames
+  `[0, 5, 10]`. The parquet SHA-256 is
+  `9abc0431f12d10c33b5b37b1bf1e6e557c8ae1c8c29fb86658969e48fcbbbf01`;
+  the mp4 SHA-256 is
+  `f58d11857651dad5983c021b56a50a68a6ce19068834c1fb5cac099219fb3a78`.
+- Input encoding: the three frames are encoded with the checkpoint ViT encoder
+  and projector. The matching real 2D action and agent-state rows are normalized
+  with the repository PushT adapter rule and encoded with the checkpoint action
+  encoder. The fixture keeps the first 8 latent and action coordinates.
+- Predictor slice: compact dimensions are `d=8`, `s=3`, `h=2`, `dh=4`,
+  `mlp=16`, `depth=2`. Every compact weight is a row and column slice of the
+  real checkpoint tensor, preserving Q/K/V head bands and AdaLN chunk structure.
+- Quantization: generated with `pwm_export.predictor_quant.bundle_quant`, using
+  calibrated SiLU, GELU, inverse-sqrt, and softmax-exp tables. The
+  `weights_root` in the JSON is the Rust predictor root for tensor ids `1000+`
+  in registration order `adaln,qkv,out,fc1,fc2` with scale ids `10+`.
+
+The fixture is intentionally small enough for default `cargo test --workspace`.
+It does not contain the full checkpoint, raw video, or raw parquet data.

crates/pwm-testkit/fixtures/lewm_predictor_real_compact.json

@@ -875,8 +875,14 @@ mod tests {
     use super::*;
     use pwm_core::audit::output_tensor;
     use pwm_core::commit::weights_root;
+    use pwm_core::serialize::canonical_bytes;
+    use pwm_core::transcript::blake2s256;
     use pwm_verifier::CommitmentKind;
 
+    const REAL_COMPACT_FIXTURE: &str = include_str!("../fixtures/lewm_predictor_real_compact.json");
+    const REAL_COMPACT_OUTPUT_DIGEST: &str =
+        "6b26564e0dd461ac784993cab5aaf4ab72ebb0ce6fe81dd9b16f6768e1f4a653";
+
     fn small() -> Dims {
         Dims {
             d: 8,
@@ -888,6 +894,40 @@ mod tests {
         }
     }
 
+    fn hex(bytes: &[u8; 32]) -> String {
+        bytes.iter().map(|b| format!("{b:02x}")).collect()
+    }
+
+    fn real_compact_circuit() -> PredictorCircuit {
+        let loaded =
+            load_real_predictor(REAL_COMPACT_FIXTURE).expect("load compact real predictor fixture");
+        assert_eq!(loaded.dims.d, 8);
+        assert_eq!(loaded.dims.s, 3);
+        assert_eq!(loaded.dims.h, 2);
+        assert_eq!(loaded.dims.dh, 4);
+        assert_eq!(loaded.dims.mlp, 16);
+        assert_eq!(loaded.dims.depth, 2);
+        assert!(loaded.input_source.contains("lerobot/pusht"));
+        assert!(loaded.weights_root.is_some());
+
+        let weights_root = loaded.weights_root;
+        let z_float = loaded.quant.z_out_float.clone();
+        let tolerance = loaded.quant.tolerance;
+        let mut circuit = build_predictor_real(
+            loaded.dims,
+            loaded.blocks,
+            loaded.x,
+            loaded.c,
+            loaded.quant.scheme,
+            loaded.quant.tables,
+        )
+        .expect("build compact real predictor");
+        circuit.export_weights_root = weights_root;
+        circuit.z_float = Some(z_float);
+        circuit.tolerance = Some(tolerance);
+        circuit
+    }
+
     fn run(d: Dims) -> Vec<i64> {
         let c = build_predictor(d);
         let artifact = prove(&c).expect("prove");
@@ -970,6 +1010,40 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn real_checkpoint_compact_fixture_proves_verifies_and_matches_digest() {
+        let c = real_compact_circuit();
+        let f_out = c.scheme.f_ln;
+        let z_float = c.z_float.clone().expect("fixture float reference");
+        let tolerance = c.tolerance.expect("fixture tolerance");
+        let artifact = prove(&c).expect("prove compact real predictor");
+        let out = verify(&artifact).expect("verify compact real predictor");
+
+        let digest = hex(&blake2s256(&canonical_bytes(&artifact.claimed_output)));
+        assert_eq!(
+            digest, REAL_COMPACT_OUTPUT_DIGEST,
+            "compact real predictor output digest changed"
+        );
+        let err = max_float_error(&out, f_out, &z_float);
+        assert!(
+            err <= tolerance,
+            "compact real predictor float error {err} exceeds {tolerance}"
+        );
+    }
+
+    #[test]
+    fn real_checkpoint_compact_fixture_tamper_is_rejected() {
+        let c = real_compact_circuit();
+        let mut artifact = prove(&c).expect("prove compact real predictor");
+        let forged_op = tamper(&mut artifact).expect("a linear op to tamper");
+        match verify(&artifact) {
+            Err(VerifyError::FreivaldsCheckFailed { op_id })
+            | Err(VerifyError::AccumulatorRange { op_id })
+                if op_id == forged_op => {}
+            other => panic!("real predictor tamper was not rejected as expected: {other:?}"),
+        }
+    }
+
     #[test]
     fn swapped_weight_is_a_model_commitment_mismatch() {
         let c = build_predictor(small());