---
project: localvm-research
document: expD_progressive_reconstruction/analysis
author: Simon-Pierre Boucher
contact: contact@spboucher.ai
created: 2026-08-12
status: reviewed
---

# Analysis — expD_progressive_reconstruction

Run: `results/expD_progressive_reconstruction/20260812T043508Z/` · code committed
before run. Qwen3-1.7B bf16 reference, affine group-64 residual ladders, 48
trajectories × 128 tokens (6 144 positions), hidden states at layers 6/13/20/27.
Bit counts below INCLUDE scale/bias overhead (+1.0 bit/param/stage at group 64).

```text
Hypothesis / Falsification
  See hypothesis.md. Kill criteria: base3+1 residual < 90% agreement, or
  two-tier policy unable to reach ≥97% with <50% escalation, or
  non-monotone hidden-state convergence. → NONE triggered.

Result
  Ladder A (3-bit stages)     agree    KL      AUROC  esc@99%  hid.err L6→L27
    stage0   4.0 bits         0.732    0.778   0.850  60.4%    0.34 → 0.83
    stage1   8.0 bits         0.957    0.024   0.952  11.0%    0.05 → 0.12
    stage2  12.0 bits         0.983    0.0023  0.980   2.6%    0.01 → 0.04
  Ladder B (4-bit stages)
    stage0   5.0 bits         0.875    0.198   0.895  35.3%    0.16 → 0.35
    stage1  10.0 bits         0.984    0.0031  0.976   2.4%    0.02 → 0.04
  Two-tier margin policies (take base decision if margin ≥ τ, else stage+1):
    B_base4 0→1: τ=2.0 → 25% escalated, 96.4% agree; τ=3.0 → 35%, 97.6%
    A_base3 1→2: τ=0.5 →  5% escalated, 97.4% agree; τ=1.0 → 12%, 97.9%
    A_base3 0→1: τ=3.0 → 44% escalated, 92.7% (3-bit base too weak alone)
  Sanity: ladder stage0 rows reproduce expG's flat 3-bit and 4-bit rows
  (0.732 vs 0.731; 0.875 vs 0.874) — pipeline consistent.

Interpretation
  1. PROGRESSIVE RESIDUAL CODING WORKS: convergence is rapid and monotone
     at every depth; each stage roughly divides hidden-state error by 5×
     and KL by ~30-60×. The margin signal stays strong at every stage
     (AUROC 0.85–0.98), so gating composes across stages — multi-tier
     escalation (G01+G02) is structurally sound.
  2. HONEST CAVEAT — static parity, not static win: at matched stored
     bytes, one-shot flat quantization is mildly better than a residual
     ladder (flat 8-bit: 98.0% @9.0 bits vs ladder 3+3: 95.7% @8.0 bits;
     ladder 4+4 @10.0 ≈ flat 8-bit @9.0). The ladder's value is therefore
     NOT compression efficiency — it is that quality becomes a *runtime*
     variable: the same stored artifact serves 5.0-bit resident execution
     and on-demand refinement, which no flat format offers.
  3. THE C1 OPERATING POINT EXISTS: 4-bit-class resident base (5.0
     bits/param incl. overhead) + margin gate at τ≈2–3 escalating 25–35%
     of tokens to base+residual yields 96.4–97.6% greedy agreement —
     within reach of the ≥97% target, using decisions, not hope.
  4. THE OPEN VARIABLE IS BYTES-PER-ESCALATION: teacher-forced escalation
     here re-runs the whole model at stage+1, i.e. touches the FULL
     residual (≈1.06 GB at 1.7B; ≈20 GB at 32B) — incompatible with the
     ~650 MB/token expH budget at scale unless (a) escalation can be
     restricted to a sensitive subset of layers/blocks, or (b) residual
     reads have strong temporal locality so the hot residual working set
     lives in RAM. Hidden-error concentration at the last layer (0.83 at
     L27 vs 0.34 at L6, 4-bit base) suggests (a) is plausible: depth-
     weighted precision or last-layers-only escalation could capture most
     of the correction for a fraction of the bytes.
  5. At the 1.7B scale used here, both base and residual fit in RAM —
     these results validate mechanisms, not end-to-end economics. Scale
     tests belong to Phase 7 prototyping.

Next experiment
  expF (error accumulation / layer sensitivity): perturb precision per
  layer group to map which layers actually need escalation — if the top
  quartile of layers captures most disagreement repair, bytes-per-
  escalation drops ~4× and C1's arithmetic closes. Then expB (temporal
  locality of the escalated set).
```