# Per-scene rates One gzip CSV per model and scene set (`__.csv.gz`) and an index (`models.csv`). Every row is one scored question about one twin of one base scene: model x base scene x twin x question type. These rows are everything Table 2, the data figures, the appendix tables, `numbers.tex` (the numbers quoted in the text), the sensitivity analysis, the heterogeneity, scene-level and extra checks are computed from (`reproduce/reproduce.py`). They were exported from the raw scoring outputs by `code/scripts/export_per_scene.py` (`export_per_scene_photo.py`, `export_per_scene_colorshape.py` for the two subdirectories). **Scene sets.** `full`: 1,000 main + 300 near base scenes (seed 424242). `api_subset`: 300 main + 150 near base scenes (seed 31337), scored with the API models and seven open models. The API subset is a separate draw, not a subset of the 1,000 scenes, although the base-scene names (`tw_main_g_0000`, ...) overlap: a scene is identified by (`scene_set`, `base_id`), and every file holds exactly one scene set. | file | scene set | twins | rows | |---|---|---|---| | 19 open models (`qwen2.5-vl-7b-instruct__full.csv.gz`, ...) | `full` | main: S, minus_c, minus_cue, swap, placebo, minus_cue_minus_c, minus_ccue, degraded_cue, S_repro; near: S, minus_c | 23,040 each | | `gpt-4.1__api_subset.csv.gz` | `api_subset` | main: S, minus_c, minus_cue, swap, placebo, minus_cue_minus_c, minus_ccue; near: S, minus_c | 6,486 | | `gpt-4o__api_subset.csv.gz` | `api_subset` | as GPT-4.1 | 6,486 | | `gpt-5.5__api_subset.csv.gz` | 250 of the 300 main API-subset scenes | S, minus_c (binding question only) | 500 | | 7 open models on the API subset (Qwen2-VL-7B, Qwen2.5-VL-7B, Qwen3-VL-8B, Qwen3-VL-32B, Mistral-Small-3.1-24B, InternVL3.5-38B, Qwen2.5-VL-72B: `__api_subset.csv.gz`) | `api_subset` | as GPT-4.1 | 6,486 each | | `photo_twins/*.csv.gz` | 463 real-photo target instances | S, minus_c_grey, minus_c_blur, placebo_grey, placebo_blur | 6,237 per model; blind run 1,389 | | `colorshape/__{easy,hard}.csv.gz` | 600 colour-shape base scenes per display (5 open models) | S, minus_c, minus_cue, minus_cue_minus_c, placebo, swap, blind | 4,200 per model and display | ## Columns | column | meaning | |---|---| | `model` | display name used in the paper | | `scene_set` | `full` (`data/gamebind_twins_full` + `data/gamebind_twins_ext`) or `api_subset` (`data/gamebind_twins` + `data/gamebind_twins_ext_api`) | | `condition` | `main` (the two events far apart) or `near` (the target's two candidate objects 1-2 tiles apart) | | `base_id` | base scene S (e.g. `tw_main_g_0000`; `g`/`t` = grid / textured skin) | | `twin` | `S` (base scene), `minus_c` (competitor idle), `minus_cue` (target's action leaves no trace), `swap` (events exchanged between agents), `placebo` (task-irrelevant floor pixels), `minus_cue_minus_c` (double deletion), `minus_ccue` (competitor's action leaves no trace), `degraded_cue` (target's trace at reduced strength), `S_repro` (an exact re-rendered copy of S, scored in the extension jobs: a scoring-calibration check) | | `qtype` | `binding` ("What did the red agent do?"), `object`, `action` | | `skin`, `target_agent` | skin of the scene; the queried (target) agent, `red` or `blue` | | `target_action`, `target_object` | the target's event (a, o) in S | | `competitor_action`, `competitor_object` | the competitor's event (a', o') in S | | `primary` | 1 if neither agent's action is `go to`: the a priori primary subset of the processing tree | | `answer` | canonical index of the correct option in this twin (empty where no answer is defined: `minus_cue`, `minus_cue_minus_c`; `swap`: the target now performs (a', o')) | | `p0`..`p3` | answer probabilities in canonical option order, averaged over the option rotations (soft response). binding: [(a,o), (a,o'), (a',o), (a',o')]; object: [o, o', fill, fill]; action: [a, a', other, other] | | `pred` | canonical index of the argmax of `p0..p3` (hard response) | | `p_competitor` | P(answer names the competitor's action a'): `p2+p3` for binding, `p1` for action; for object P(answer names o') = `p1` | | `correct` | 1 if `pred == answer` (empty where no answer is defined) | | `n_rotations` | option rotations averaged: 4 (open models, next-token letter probabilities), 2 (GPT-4.1 and GPT-4o, top-20 log-probabilities of the answer letter; GPT-5.5, one parsed answer per rotation, so its soft response is a vote share) | Probabilities are written with full double precision so that the reproduction is bit-identical; the rows of each model come from one scoring run (one GPU type, one batch size). The per-rotation probabilities are not released (only their mean `p0..p3`); the analysis uses the mean and the argmax only. The photo-twin files have the same columns plus `protocol`, `dataset` (vcoco / vg) and `photo_id`, without `scene_set`, `condition`, `skin` and `primary`. The colour-shape files (`colorshape/`, question "What color is the ?") have the columns `model`, `display` (`easy`: `data/colorshape_twins`, large saturated shapes, 1-2 grey distractors; `hard`: `data/colorshape_twins_hard`, small shapes among 14 coloured distractors, colours at 15% saturation), `base_id`, `twin`, `distance` (near / far), `target_shape`, `competitor_shape`, `target_color`, `competitor_color`, `answer` (empty for minus_cue, minus_cue_minus_c and blind), `p0..p3` (canonical order [target colour, competitor colour, absent, absent], mean over 4 rotations), `pred`, `lm0..lm3` (probability mass on the four option letters before renormalisation, per rotation) and `n_rotations`. ## Example: GPT-4.1's competitor effect and processing tree ```python import pandas as pd d = pd.read_csv("gpt-4.1__api_subset.csv.gz") d = d[d.condition == "main"] b = d[d.qtype == "binding"].pivot(index="base_id", columns="twin", values="p_competitor") print("kappa_A =", (b.S - b.minus_c).mean()) # all 300 scenes (Table 2: 15.5 pts) prim = d[(d.qtype == "binding") & (d.primary == 1)].pivot(index="base_id", columns="twin", values="p_competitor") prim = prim.dropna(subset=["S", "minus_c", "minus_cue", "minus_cue_minus_c"]) pi_S, pi_c, b1, b0 = (prim[t].mean() for t in ("S", "minus_c", "minus_cue", "minus_cue_minus_c")) p_A = 1 - pi_c / b0 m_A = (pi_S - (1 - p_A) * b1) / p_A print(f"n={len(prim)} p_A={p_A:.2f} m_A={m_A:.3f}") # n=145 p_A=0.82 m_A=0.153 ```