CognPhys — Rule Induction from Physics Video

CognPhys evaluates whether vision-language models can induce the rules that govern a world from observation, rather than recalling known physics. Every world is produced by a procedural rule engine in which the governing law deviates from Newtonian mechanics along one controlled axis: gravity points sideways instead of down, a collision injects a velocity delta that is independent of the struck body's mass, a central force falls off as 1/d^p with a free exponent p, a vortex field does net work around a closed loop, a patch of floor decelerates irrespective of the normal force, and a hard speed cap replaces the terminal velocity that dissipation would produce.

The model sees video only. It is asked which rules are in force, what the rule's parameters are, and where the object will be next. Because the rules are not the ones any model has seen in training, the tasks cannot be answered from memory of textbook mechanics.

The generator supports a larger library than this release uses (including non-Markovian rules that depend on accumulated collision counts or contact duration, and rules that teleport a body back to its own past position). The four tracks below ship the subset that passed their validation gates; only the rules listed in Task definitions appear in these files.

Every score is reported against two reference lines measured on the same pixels: a no-video prior (answer the family median without looking) and a classical-CV ceiling (a hand-built estimator that sees only the same frames). This makes a low score a statement about the model rather than about the task.

All model-facing text is Chinese (hence language: zh). This card describes the prompts in English; the verbatim strings — which are what the models were actually shown — live in the banks (items[].prompt, prompt_template, prompt_labels, and each ablation item's question).

---

What is in the release

Track / directory	Clips	Annotation items	Unique worlds	Clip length	Task
track_a/	150	150	150 (75 twin pairs)	12 s (100) / 20 s (50)	Estimate the rule's SI parameter
track_a_plus/	150	150	same 150 worlds	12 s / 20 s	Same task, 45° camera view
track_b/	136	178	134	14 s	Name every rule in force (closed set of 11)
ablation/	80	80	80 (40 counterfactual pairs)	12 s	Forced two-choice on paired worlds

All clips are 800 × 600, 30 fps, mpeg4 (MPEG-4 Part 2). Track A and Track B additionally ship H.264 review copies under watch/ — see Codec note.

Repository structure

track_a/
├── clips/<world_id>__fixed.mp4          150 clips
├── questions.json                       the bank: prompts, ground truth, params, reference estimates
├── worlds/<world_id>/
│   ├── world_spec.json                  the rule program (rule ids, kinds, params), object prototypes,
│   │                                    render config, difficulty vector
│   ├── world_meta.json                  family, param name, unit, ground truth, human prompt
│   └── episodes/ep_000/states.jsonl     per-frame ground truth, 30 fps
├── future_truth.json                    +1 s position-prediction truth (30 worlds)
├── future_truth_75.json                 75 %-of-duration truth (same 30 worlds)
├── future_truth_ceiling.json            rule-replay ceiling for the +1 s horizon
├── future_truth_75_ceiling.json         rule-replay ceiling for the 75 % horizon
├── watch/                               H.264 review copies + contact sheet (human inspection only)
└── RESULTS.md                           full report for Track A / A+

track_a_plus/
├── clips/<world_id>__plus.mp4           150 clips, same worlds, 45° camera
├── questions.json                       copy of the Track A bank, `clip` repointed, `view: plus_45deg`
├── future_truth.json / future_truth_75.json
└── watch/

track_b/
├── clips/<world_id>__fixed.mp4          136 clips (134 referenced by the bank + 2 unreferenced)
├── questions.json                       178 items + the closed-set taxonomy and prompt labels
├── examples.json                        one rendered example prompt per rule combination
├── cv_features.json                     classical-CV features per world (the same-pixel ceiling input)
├── watch/                               H.264 review copies, named with the true rule set
└── RESULTS.md

ablation/
├── clips/<world_id>__fixed.mp4          80 clips (40 pairs)
├── questions.json                       80 items: question, options, answer, strength
├── tables.json                          the text-only condition: 2 fps trajectories + classical readout
└── RESULTS.md

states.jsonl is one JSON object per frame: {"frame", "timestamp", "objects": [{"id", "name", "position_x/y/z", "velocity_x/y/z", "radius", "mass", "group", "active", "color", "role", "orientation", "angular_velocity"}]} — 360 lines for a 12 s clip, 600 for a 20 s clip. Line 0 of the file is already one 1/30 s step past the launch state that the video's first frame shows.

Initial conditions are fixed by the generator rather than stored per world. Most families fire the red target (object A) from (x = 150, y = 300) along +x at 150 px/s; the _hit families fire it faster (250, 450 or 550 px/s) so that it reaches the stationary blue body within the clip, and the two field families use a diagonal "orbit" launch so the body sweeps a range of distances from the field centre. The arena is 800 × 600 px at 50 px = 1 m. Read line 0 of states.jsonl for the exact starting state; ball radii are drawn from 17–23 px per world.

---

Task definitions

Track A / A+ — parameter estimation

Each world is governed by exactly one rule. The prompt names the rule family and asks for its parameter in SI units; the model must supply the value from pixels alone (no pixel scale and no frame interval are given in the default condition).

Example (gravity_g, translated): "The ball moves with uniform acceleration on a horizontal surface. Estimate the magnitude of its acceleration g."

Track A's 15 families and their units:

Family	Parameter	Unit
gravity_g	gravitational acceleration	m/s²
drag_b	linear drag coefficient	1/s
roll_resist, roll_resist_hit	rolling deceleration	m/s²
friction_zone, friction_zone_hit	local braking-zone deceleration	m/s²
push_zone, push_zone_hit	local pushing-zone acceleration	m/s²
two_zone, two_zone_hit	two-zone contrast	m/s²
push_brake_zone, push_brake_zone_hit	push-then-brake contrast	m/s²
field_strength	central field acceleration at d = 2 m	m/s²
field_exponent	power-law exponent p	— (dimensionless)
impact_dv	collision velocity delta	m/s

Worlds ship one or two bodies. drag_b, field_strength and field_exponent contain only the red target (A). The other 12 families also place a blue second body (B): in the _hit variants (20 s clips) B sits stationary on A's path so the two collide mid-episode; in the remaining families B is parked off the lane at (620, 460) and never interacts.

Each item carries: gt (ground truth), unit, ref_estimate / ref_rel_err (the classical-CV reference and its error), prior_median (the family median, i.e. the no-video answer), effect_bd (median frame-wise divergence between this world and its parameter-nulled twin, in ball diameters — the difficulty axis, range 0.77–12.07), pair_id and twin (a/b).

Track B — rule identification

Closed-set identification over 11 rule types; each world is governed by 2–4 of them (152 items with 2 rules, 13 with 3, 13 with 4). Scoring is exact set match, with precision/recall reported alongside so that "list every rule" is penalised.

Key	Label shown to the model (translated)	Gloss shown to the model (translated)
accel	uniform acceleration	constant external force; speed increases uniformly
drag	viscous drag	resistance proportional to speed, so speed decays exponentially (fast at first, then slower)
roll	rolling resistance	the ground decelerates it continuously — linear deceleration throughout, with no coloured patch
brake_patch	local braking patch	a patch of differently coloured ground where it decelerates noticeably faster
push_patch	local pushing patch	a patch of differently coloured ground that pushes it continuously
terrain	terrain contrast	two differently coloured regions act differently (one pushes, or one is stronger / weaker)
field	central attractive field	attraction toward a fixed point, inversely proportional to distance; the trajectory bends toward it
power_field	power-law field	also points at a fixed point, but the force falls off as a power law in distance (exponent ≠ 1)
vortex	vortex field	tangential force rotating about a fixed point (the body circles it)
impact	collision impulse	after a collision the struck ball suddenly gains speed
speed_cap	speed cap	speed quickly reaches a ceiling and stops increasing (terminal speed)

The label and gloss strings above are the ones the model actually reads, and they are Chinese in the files — the English here is a translation for orientation only. Copy them from track_b/questions.json → prompt_labels (each entry has a short label and a gloss) rather than re-translating, or you will change the prompt.

The bank's own taxonomy field holds internal keys and is not the text shown to models; the prompt text is built from prompt_labels. rule_signatures records, per rule, whether the generator verified an observable signature for it in this world's trajectory.

Position prediction (30 items, future_truth*.json)

Only the first half of the clip is shown (12 frames for 12 s worlds, 20 for 20 s worlds, 2 fps) and the model must give the red ball's centre in pixels at a future time — T_pred = 7.0 s for 12 s worlds and 11.0 s for 20 s worlds (the +1 s horizon), or 9.0 / 15.0 s (the 75 % horizon). Two worlds per family, 30 total. Truth files give, per world, truth_xy, last_seen_xy (the "stayed put" baseline), const_vel_xy (the "kept its velocity" baseline), ball_px (the apparent ball diameter in pixels, 34–46 px — i.e. a 17–23 px radius, the normaliser) and tracker_coords (the classical tracker's per-frame centres).

Error is normalised by that world's own ball radius (ball_px / 2). Thresholds are quoted in ball radii; see Thresholds.

Ablation — counterfactual pairs

40 pairs of worlds that share a seed and therefore identical initial conditions, differing only in the rule (pushed vs braked; attracted vs repelled). A model reading the dynamics must answer the two members differently. Two question kinds, 40 items each:

• push_brake (translated): "When the ball crosses the differently coloured region, is it pushed (speeds up) or slowed down?" → options: pushed / slowed down
• attract_repel (translated): "A force field exists somewhere in the scene and affects the ball. Does it point toward that location or away from it?" → options: toward / away

The question text, the options and the answer key are Chinese strings in the bank (question, options, answer); the English above is a translation. Option order is flipped for odd-numbered pairs in the reference harness, and grading always compares against answer.

Answers are perfectly balanced (20 / 20 / 20 / 20). tables.json holds the text-only variant of the same items: a 2 fps (time, x, y) trajectory table per world, plus the classical sign-test readout.

---

Reference evaluation protocol

The reported numbers use this input protocol. Reproduce it if you want comparable scores.

Task	Frame rate	Frames attached	Notes
Track A / A+	2 fps	≤ 16 (t = 0 → 7.5 s)	frames sampled densely from t = 0, then truncated
Track B	1.2 fps	17	covers 13.3 s of 14 s
Position prediction	2 fps	12 or 20	exactly the first half of the clip
Ablation (video)	2 fps	16
Ablation (table)	2 fps	—	24 text rows over the full clip

Frames are JPEG quality 85, sent as images in a single user message (no native video input), with detail="low" on OpenAI-compatible endpoints. Local open-weight models are run at long side 512 px to match what detail="low" downsampling approximates. Answers are parsed from the last line matching the answer marker the prompt asks for (the literal marker string is Chinese); a reply with no parseable answer counts as a miss.

Recommended decoding for the clips:

import json, cv2
bank = json.load(open("track_a/questions.json"))
item = bank["items"][0]
cap = cv2.VideoCapture(item["clip"])   # mpeg4; see codec note below
frames = []
while True:
    ok, frame = cap.read()
    if not ok:
        break
    frames.append(frame)

Codec note

The clips/ files are MPEG-4 Part 2 (mpeg4, yuv420p). Most browsers cannot play this profile in an HTML5 <video> element, so the Hub preview will not render them; use ffmpeg or OpenCV. track_a/watch/ and track_b/watch/ contain H.264 re-encodes (~5× smaller) intended for human inspection — they are not the files the experiments were run on, so do not use them to reproduce published numbers. If you need browser-playable copies of the canonical files, transcode with ffmpeg -i in.mp4 -c:v libx264 -crf 18 out.mp4.

---

Reference points (how to read a score)

Task	Metric	Best model	No-video / naive baseline	Same-pixel ceiling
Track A parameter estimation	acc@10	15.3 %	24.0 % (family median, no video)	90.7 % (classical CV)
Track B rule identification	exact set match	21.3 %	1.6 % (random subset)	15–96 % per rule
Position prediction, +1 s	≤ 0.15 r	33.3 %	43 % (kept its velocity)	87 % (rule replay)
Ablation two-choice	per-item accuracy	85–97.5 %	—	100 % (80/80, classical sign test)

Three readings the numbers support:

1. No model clears the no-video line on parameter estimation — the best model (15.3 %) is below the family-median prior (24.0 %), while the classical CV estimator on the same pixels reaches 90.7 %.
2. On position prediction, models are still worse than naive extrapolation (33.3 % vs 43 %), while replaying the world's own rules reaches 87 % — the task itself is solvable.
3. The ablation two-choice is a positive control: frontier models do change their answer when the rule flips (implying they read the dynamics), which rules out "the model simply cannot see the scene" as an explanation for the failures above.

Thresholds: read this before comparing numbers

The literature on this dataset quotes position-prediction accuracy at two different thresholds, and the same model/horizon reads differently under each:

Threshold	Rule-replay ceiling	"Kept its velocity"	Best model
0.25 r (used in track_a/RESULTS.md)	90 %	53 %	43 %
0.15 r (used in the README, figures/task_radar_scores.csv and the paper)	87 %	43 %	33 %

Do not go below 0.15 r: at 0.10 r and 0.05 r the perfect-physics ceiling falls to 50 % and 33 % while the naive baseline barely moves, i.e. the metric starts measuring integration and readout noise rather than physical understanding. Pick one convention and state it.

---

Known limitations

TODO — to be completed before public release.

Citation

@misc{cognphys2026,
  title  = {CognPhys: A Rule-Induction Benchmark for Physics Video},
  author = {<TODO: authors>},
  year   = {2026},
  note   = {<TODO: arXiv id / venue once available>}
}

License

Released under CC-BY-4.0. All scenes are synthetic renders of procedurally generated simulations: there is no real-world footage, no human subject, and no personally identifiable information. You are free to redistribute and adapt the data with attribution; if you build on the benchmark, please cite the paper above.