experiments/hypotheses.md

# Experimental Program: Frames vs. Spatial Code vs. Both

Grounded in VSI-Bench ("Thinking in Space", arXiv:2412.14171) and "Thinking with
Spatial Code" (arXiv:2603.05591). Every experiment below is runnable with the existing
infrastructure: harness A (frames only), harness B (spatial-code text only), harness C
(frames + code, same-source config), original/compact code formats, uniform/selective
frame selection, frame counts, three VLMs (Qwen3.5-4B, Qwen3.5-2B, InternVL3.5-4B),
the 16-token direct protocol vs. the 2048-token extended-reasoning protocol, and the
consolidated /workspace/analysis package (per-category official scores, reasoning-token
and forced-answer telemetry, cross-harness join).

Anchor findings from the two papers:
- VSI-Bench error taxonomy: ~71% spatial reasoning (40% relational, 31% ego-allo
  transform), ~15% perception, ~14% linguistic.
- CoT / self-consistency / ToT HURT frames-only VSI-Bench (up to -21% on size tasks).
- Model-generated cognitive maps helped relative distance 46->56; GT maps -> 66.
- Spatial-code paper: predicted codes 60.0 overall, ground-truth codes 73.2 with the
  same 4B LLM -> perception, not reasoning capacity, is the binding constraint.

---

## Theme 1 — Representation substitution (A vs B)

**H1 (code-for-frames substitution).** B (code only) >= A (frames only) on the
metric-geometry categories (absolute distance, object size, room size, relative
distance), because ~71% of frame-based errors are spatial-reasoning errors that
explicit coordinates eliminate; A retains the edge only on appearance-dependent
categories. Run: A vs B, all 3 models, selective/32 and selective/64, both protocols.

**H2 (informed-blind baseline).** VSI showed vision-disabled models score below chance.
B is "blind but informed" — the B-minus-blind gap is a direct measure of the code's
usable information content per category. The appearance-order category is the sharp
sub-case: the code carries first-visible-time (compact) / appearance order (original),
so B should massively beat both blind AND frames-only baselines on the paper's hardest
category (32.5 even with codes+RL) — if the model actually reads the legend. Failure
here isolates schema-grounding failure, not information absence.

**H3 (ego-allo split).** The code is allocentric (world frame). B improves allocentric
tasks (rel/abs distance, size, room size, counting) but NOT egocentric tasks (relative
direction, route planning), which need the observer's viewpoint that the code lacks.
This maps VSI's 31%-ego-allo error class onto a controlled input manipulation.

## Theme 2 — Complementarity and conflict (C vs A, B)

**H4 (complementarity is category-selective).** C > max(A, B) only where the two
modalities carry disjoint information: relative direction and route planning (frames
restore the egocentric viewpoint; code supplies exact geometry). On pure-metric
categories C ~= B (frames redundant); on appearance order C ~= best single modality.

**H5 (cross-modal interference).** For the 2B model, C < B on metric categories:
thousands of extra visual tokens act as distractors when the code already suffices —
a capacity x redundancy interaction absent at 4B.

**H6 (textual anchoring under conflict).** Where the encoder's code is wrong (predicted
codes carry perception error), C follows the code, not the frames — VLMs anchor on
text. Measure per-question "code dominance": among questions where A and B disagree,
what fraction of C's answers side with B? Follow-up (small new script): perturb one
object's position/size in the code fed to C and measure how often the answer tracks
the perturbation despite contradicting frames.

## Theme 3 — Reasoning protocol (16-token vs 2048-token extended)

**H7 (the CoT reversal — headline hypothesis).** VSI-Bench's "CoT hurts" finding is a
representation problem, not a reasoning problem: extended reasoning HURTS or is flat
for A (replicating the paper) but HELPS for B and C, because reasoning over explicit
coordinates is symbolic computation (arithmetic, projections) that benefits from
serial steps, whereas reasoning over frames forces error-amplifying visual
imagination. Design: 2 (protocol) x 3 (harness) x 8 (category), all models. A positive
interaction term is a novel, publishable result: "chain-of-thought fails for spatial
video reasoning only when the space is implicit."

**H8 (dose-response / overthinking).** Within extended B/C records, accuracy vs.
reasoning_token_count is inverted-U; records that hit the 2048 cap and were forced
("Final answer:") score worst — rumination as a measurable failure mode. We log
reasoning_token_count, hit_token_limit, forced per record; no new code needed.

**H9 (forced answers are informative).** Forced-continuation answers still beat chance
on MCA tasks — truncated reasoning traces carry decision-relevant state. Compare
forced-record accuracy vs. category chance level.

**H10 (extended mode rescues small models on B).** The 4B-vs-2B gap under the 16-token
protocol on B shrinks under extended reasoning: small models can't one-shot multi-step
coordinate arithmetic in 16 tokens but can when allowed to externalize steps. Scale x
protocol interaction, B only.

## Theme 4 — Code format (original vs compact)

**H11 (precomputation vs derivation x token budget).** Original embeds a precomputed
pairwise distance table; compact gives raw OBBs only. Under the 16-token protocol,
original wins on distance categories (answer = table lookup); under extended
reasoning, compact catches up or wins (the model derives what it needs, and the table
is 30 lines of distraction for non-distance questions). A budget x format crossover.

**H12 (verbosity x capacity).** Compact's fuller schema helps 4B models and hurts 2B
(context distraction) — format x scale interaction, measurable per category.

**H13 (schema-grounding).** Because original is now provably derivable from compact,
any B(original) vs B(compact) gap is purely presentational, not informational — a
clean measurement of how much "representation surface form" matters to VLMs, holding
information content mathematically fixed. This is a control neither paper could run.

## Theme 5 — Perception inputs (frame selection and count)

**H14 (code as frame compression).** C at low frame counts matches A at high frame
counts: quantify the "frame-equivalent value" of the code (e.g., C@8 ~= A@64). Report
as an input-token/accuracy Pareto frontier (input_token_count is logged per record) —
an efficiency argument for symbolic intermediates.

**H15 (selection matters more upstream than downstream).** For A, selective vs uniform
frames changes what the VLM sees; for B, selection only changes what the encoder saw
when building the code. Prediction: the selective-vs-uniform effect on B (via code
coverage/quality) exceeds its effect on A — perception curation compounds through the
encoding stage. (Requires building uniform-selection codes; currently only selective
exists on disk.)

**H16 (frame-count saturation shifts by modality).** A saturates at moderate frame
counts (VSI models used 8-32); B's accuracy vs. the frame count used to BUILD the code
keeps rising longer (more frames -> more tracked objects -> more complete code), i.e.,
the saturation point of frames-as-pixels is earlier than frames-as-evidence-for-codes.
Compare A@{8,16,32,64} vs B(code built from {32,64}).

## Theme 6 — Model family and scale

**H17 (family x modality).** InternVL3.5-4B vs Qwen3.5-4B rank-flips between A and B:
vision-centric training helps A, text/instruction strength helps B. Code-reading is a
distinct capability from video understanding, poorly predicted by video benchmarks.

**H18 (scale gap is modality-dependent).** The 4B-2B gap is larger on B than A under
the 16-token protocol (symbolic reasoning scales faster than perception at these
sizes), and H10 predicts extended mode closes it.

## Theme 7 — Question-level error decomposition (the empirical version of VSI's manual taxonomy)

**H19 (automatic perception/reasoning split).** Join A, B, C per question (same
question ids across harnesses). Classify each question: solved-by-B-not-A (frames'
failure was perception-or-imagination), solved-by-A-not-B (code missing needed info —
appearance/visibility), solved-by-neither (reasoning failure or question pathology),
solved-by-C-only (genuine fusion). This reproduces the paper's 71/15/14 manual error
taxonomy automatically and at full-benchmark scale. Analysis-only: pairwise McNemar
tests + per-category contingency tables over existing result JSONs.

**H20 (cognitive-map generalization).** The spatial code is an externally supplied,
metrically exact cognitive map. VSI's cog-map gain concentrated in relative distance
(46->56->66 with GT). Prediction: B's gains over A concentrate in the same place, and
exceed the GT-cog-map ceiling (66) because the code is 3D and metric while the 10x10
grid map was 2D and coarse — positioning our result as the limit of that paper's
cognitive-map line.

---

## Execution plan — staged, config-narrowing design

This is the actual plan being run, not a full factorial: each stage sweeps its own axes,
picks a single winning configuration from the results, and freezes that configuration
for the next stage. Every stage always sweeps all 3 models — the model axis is never
collapsed, only frame count / input selection / spatial-code format are.

**Stage 1 — Plan A decides frame count AND selection.**

```bash
python -m harness.A.sweep --models all --frame-selections all --frames 16,32,64
```

9 configs (3 models x 2 selections x 3 frame counts {16, 32, 64}), 16-token protocol.
Aggregate with `analysis.aggregate --harness A`; for each `(frame_selection,
frame_count)` cell, average the "overall" official score across all 3 models; the
argmax cell is `(selection*, frames*)`. This single pair is frozen for every later stage
— both harness B's `--input-selections` and harness C's `--input-selections`, and both
harnesses' `--frames`.

**Stage 2 — Plan B decides spatial-code format.**

```bash
python -m harness.B.sweep --models all --spatial-code-formats all \
  --input-selections <selection*> --frames <frames*>
```

6 configs (3 models x 2 formats), input selection and frame count fixed from Stage 1.
Aggregate with `analysis.aggregate --harness B`; average "overall" across the 3 models
per format; the argmax format is `format*`.

**Stage 3 — Plan C runs the fully-fixed config.**

```bash
python -m harness.C.sweep --models all --spatial-code-formats <format*> \
  --input-selections <selection*> --frames <frames*>
```

3 configs (one per model) — every non-model axis is now fixed by Stages 1-2, so C's own
sweep only varies the model.

**What this buys and what it costs.** A, B, C become directly comparable at one
apples-to-apples configuration chosen by A's own best showing — clean for H1/H4/H5/H6/
H17 (representation and complementarity questions at the single best operating point).
It costs the multi-config comparisons: H3/H7/H10/H11/H18 (protocol and format
interactions across several configs) and H14-H16 (frame-count/selection curves across
harnesses) need B/C runs at MORE than the one frozen config to observe an interaction or
a curve, not just a single point. Two ways to get those without abandoning the staged
design:
- Re-run Stage 2/3 sweeps a second time under the extended (2048-token) protocol at the
  same frozen `(selection*, frames*)` — gives the 16-token-vs-extended comparison (H7,
  H10) "for free" at the chosen config, no new axis to pick a winner from.
- Treat frame-count/selection curves (H14, H15, H16) as a separate, explicitly
  secondary sweep — rerun B/C at the other Stage-1 frame counts too, after the staged
  pipeline's headline results are in, only if those hypotheses are still of interest.

**Always-available, no extra runs needed:**
- **Telemetry analyses** (H8, H9, H19, H20): pure analysis over whatever result JSONs
  already exist (reasoning_token_count bins, forced-rate vs score, cross-harness
  per-question join) — run after every stage, not gated on the full plan finishing.
- **Perturbation probe** (H6 follow-up): small script cloning harness C with a
  position/size-perturbed code for ~100 sampled questions from the frozen C config.
- **Uniform-selection code build** (only relevant if Stage 1 picks `selective`, since
  `H15` specifically wants the OTHER selection's encoder-side effect): gated on
  regenerating SAM3 raw caches for uniform input, currently absent on disk.

Statistics: per-question paired comparisons (McNemar for MCA, paired bootstrap over
questions for MRA), per-category and overall; all scoring through the official
vsibench aggregator already wired into /workspace/analysis.

Expected headline results if hypotheses hold: (i) CoT-reversal interaction (H7, needs
the extended-protocol re-run above), (ii) automatic error-taxonomy decomposition (H19),
(iii) format-as-pure-presentation control (H13), (iv) textual anchoring under modality
conflict (H6).