Datasets:

VideoWorldmodel
/

ReasoningStructureTestset

@@ -19,267 +19,234 @@ size_categories:
 # Reasoning-Structured Videos
-**A Stratified Diagnostic Suite for Compositional Consistency in Action-Conditioned Video World Models.**
-Reasoning-Structured Videos is a UE5-rendered video benchmark whose trajectories are organised as **rooted graphs with path-level algebraic relations**. Unlike flat corpora that release independent action–observation rollouts, every released trajectory here is annotated as an exact instance of one of three identities a faithful transition operator must satisfy:
-- **Inverse** &nbsp; `T_{A⁻¹} ∘ T_A(s₀) = s₀` &nbsp; — a path followed by its reverse returns to the start.
-- **Loop** &nbsp; `T_A(s₀) = s₀` &nbsp; — a topologically closed action sequence closes in state space.
-- **Equivalence** &nbsp; `T_A(s₀) = T_B(s₀), A ≠ B` &nbsp; — two distinct sequences reach the same state.
-These are *across-path* properties invisible to any single-rollout metric (FVD, LPIPS, PSNR), and the dataset is, to our knowledge, the first video corpus that supplies them as constructed annotations rather than mining attempts. The accompanying analysis shows that random sampling cannot supply this signal: the density of algebraically meaningful pairs decays exponentially in path length, so the supervisory signal is **constructed by geometry** rather than discovered.
-> Companion paper: *Reasoning-Structured Videos: A Stratified Diagnostic Suite for Compositional Consistency in World Models* (NeurIPS 2026 Datasets & Benchmarks, under review).
----
-## Dataset at a Glance
 | Field | Value |
 |---|---|
 | Engine | Unreal Engine 5 |
-| Scenes | ~30 independently authored indoor / outdoor / mixed environments |
-| Modality | RGB (mp4, H.264) + per-frame action labels + relation metadata + per-step pose & collision records |
-| Resolution / FPS | 1280 × 720, 16 fps |
-| Trajectory length | 40 actions × 9 frames/action = **360 frames** (~22.5 s) per trajectory |
-| Action space | 9 discrete primitives: `move_{forward, backward, left, right}`, `turn_{left, right}`, `look_{up, down}`, `no_op` |
-| Action grid | translation Δ = 100 cm, yaw Δ = 15°, pitch Δ = 7.5° |
-| FOV | 79° (Habitat convention) |
-| Release format | 5 zip files (one per split), ≈ 14 GB total |
-| Total trajectories released | **1,377** (passing the two-layer pixel validator) |
-This release is the **pixel-validated test corpus** used in the companion paper's Tables 1–2 (Easy tier) and the Hard-tier supplement. Trajectories whose realised pose deviated from the expected pose by > 1 cm at any step were routed to a `random_walk/` split during rendering and are **not included** here — every released trajectory has its algebraic identity holding exactly (Layer 1: pose check) and validated to MSE tolerance on captured frames (Layer 2: pixel check).
-### Per-split breakdown
-| Split | Tier | # trajectories | # mp4 files | Size (compressed) | Construction |
-|---|---|---|---|---|---|
-| `inverse_easy`     | Easy | 246 | 246 | 2.09 GB | Sampled `A` ‖ `no_op`-pad ‖ `A⁻¹` |
-| `inverse_hard`     | Hard | 202 | 202 | 1.99 GB | `A·A⁻¹` mixing rotations (non-abelian witness) |
-| `loop_easy`        | Easy | 247 | 247 | 2.17 GB | Five-stage discrete return |
-| `loop_hard`        | Hard | 198 | 198 | 2.27 GB | Topologically closed polygons (rectangle / triangle / hexagon) |
-| `equivalence_easy` | Easy | 484 (= 242 paired pairs) | 484 | 4.56 GB | Stage-1 commutative shuffle / Stage-2 L-shape vs. zig-zag |
-Equivalence trajectories are released as `(A, B)` pairs; both halves of each pair are present in `equivalence_easy`. Hard-tier Equivalence is held back for a future release.
----
-## How the Data Is Constructed
-For each scene, root states are sampled on a 200 cm XY grid with 8 yaw orientations per cell and filtered by capsule-overlap tests against scene geometry. From every valid root, trajectories are emitted by one of three constructive families so the algebraic identity holds **exactly on the captured frames**, absent collision:
-- **Inverse paths.** A natural `K`-step path `A` (`K ∈ {10, …, 20}`) interleaves translation blocks and rotation blocks, then is concatenated with its action-wise reverse `A⁻¹` and `no_op`-padded to the fixed horizon. Translations and rotations do not commute, so reversal demands tracking of the non-abelian sequence.
-- **Loop paths.** Two complementary constructions: (i) sampled exploration plus a five-stage discrete return (yaw → pitch → forward/backward → lateral) accepted only when residuals fall below 0.45 Δ horizontal / 0.3 Δ vertical; (ii) **topologically closed polygons** (rectangle / triangle / hexagon) whose closure is exact by polygon geometry.
-- **Equivalent paths.** Stage 1 — Fisher–Yates shuffle within each maximal mono-type segment of consecutive translations or consecutive rotations (commutative shuffle); Stage 2 fallback — matched **L-shape** `Uᵐ Vⁿ` vs. **zig-zag** `(UV)ᵏ Uᵐ⁻ᵏ Vⁿ⁻ᵏ` pairs (`m, n ∈ [3, 6]`) with self-inverse rotation pairs filling remaining slots, sharing only origin and terminus with disjoint interiors.
-### Easy tier vs. Hard tier
-The paper distinguishes two tiers per relation (paper §3.2, §4.3):
-- **Easy tier** — the constructions above. These are the constructions used to render the original Easy-tier corpus and form the bulk of this release (`*_easy`).
-- **Hard tier** — defended against shortcut attacks (e.g. MIND-style symmetric round-trip baselines). Released splits:
-  - `inverse_hard` — `A·A⁻¹` whose `A` mixes translations *and* rotations, providing a **non-abelian witness** that cannot be solved by treating the inverse half as a literal time-reversal.
-  - `loop_hard` — pure geometric polygon templates (rectangle / triangle / hexagon) that are *not* decomposable into Inverse, so a model cannot pass Loop simply by passing Inverse.
----
-## Deterministic Capture Pipeline
-To make the rendering function `g: S → X` effectively deterministic — required for any cross-path pixel comparison to be attributable to the model rather than to scene drift — the renderer applies:
-- frozen directional lighting, HDR capture path (`SCS_FinalColorHDR` + RGBA16F), clamped auto-exposure;
-- 15 warm-up frames discarded after every teleport (Lumen GI / auto-exposure settling);
-- temporally unstable effects disabled (motion blur, depth-of-field, lens flares, ray tracing);
-- rigid capsule embodiment (radius 34 cm, half-height 88 cm) with the camera 60 cm above its centre.
-These settings are pinned in `DataCollector.h` / `DataCollector.cpp` of the rendering codebase released alongside the dataset.
----
-## File Layout
-The release ships as five zip files. After decompression:
-```
-result_dataset/
 ├── inverse_easy/
-│   ├── run_<TIMESTAMP>__traj_<ID>.mp4         # RGB rollout, 360 frames
-│   └── run_<TIMESTAMP>__traj_<ID>_meta.json   # actions, root state, per-step pose, relation
 ├── inverse_hard/
-│   └── ...
 ├── loop_easy/
-│   └── ...
 ├── loop_hard/
-│   └── ...
 └── equivalence_easy/
-    ├── run_<TIMESTAMP>__pair_<PID>_A_traj_<TID>.mp4         # path A
-    ├── run_<TIMESTAMP>__pair_<PID>_A_traj_<TID>_meta.json
-    ├── run_<TIMESTAMP>__pair_<PID>_B_traj_<TID+1>.mp4       # path B (paired)
-    └── run_<TIMESTAMP>__pair_<PID>_B_traj_<TID+1>_meta.json
 ```
-### Filename schema
-- **Single-trajectory splits** (`*_easy` for Inverse / Loop, `*_hard`): `run_<RUN_TIMESTAMP>__traj_<TRAJ_ID>.mp4` paired with `..._meta.json`.
-- **Equivalence pairs**: `run_<RUN_TIMESTAMP>__pair_<PAIR_ID>_<A|B>_traj_<TRAJ_ID>.mp4` — the `pair_<PID>` token uniquely identifies the (A, B) pair across the split, and the `_A_` / `_B_` token disambiguates the two halves. The two halves' `TRAJ_ID`s are always consecutive.
-### `_meta.json` schema (key fields)
 ```json
 {
   "trajectory_id": 353,
-  "data_type": "reasoning",
   "trajectory_type": "inverse",
-  "algebraic_property": "inverse: A ∘ A⁻¹ = id (explore then reverse)",
-  "paired_trajectory": {
-    "is_paired": false
-  },
-  "has_collision": false,
-  "collision_count": 0,
   "total_steps": 40,
   "frames_per_step": 9,
   "total_frames": 360,
-  "render_config": {
-    "resolution": [1280, 720],
-    "fov": 79.0,
-    "image_format": "jpeg",
-    "modalities": ["rgb", "depth"]
-  },
-  "root_state": {
-    "position": [-2490.0, 1200.0, 400.0],
-    "rotation": [0.0, 240.0, 0.0]
-  },
-  "action_sequence": ["move_right", "turn_right", "look_down", "...", "move_left"],
-  "collision_mask": [0, 0, 0, "..."],
-  "steps": [
-    {
-      "step": 0,
-      "action": "move_right",
-      "action_id": 3,
-      "start_pos": [-2490.0, 1200.0, 400.0],
-      "start_rot": [0.0, -120.0, 0.0],
-      "expected_end_pos": [-2403.4, 1150.0, 400.0],
-      "actual_end_pos":   [-2403.4, 1150.0, 400.0],
-      "actual_end_rot":   [0.0, -120.0, 0.0],
-      "collision": false,
-      "collision_displacement": 0.0,
-      "frame_dir": "step_00"
-    }
-  ],
-  "video_encoding": {"fps": 16.0, "crf": 28, "resolution": "1280x720", "codec": "libx264"}
 }
 ```
-For Equivalence pairs, `paired_trajectory` is populated:
-```json
-"paired_trajectory": {
-  "is_paired": true,
-  "role": "path_A",
-  "primary_trajectory_id": 23,
-  "partner_trajectory_id": 24,
-  "relation": "path_A and path_B are commutative shuffles, should reach same final state"
-}
-```
-> **Note on the `modalities` field.** Some `_meta.json` files list `"depth"` in `render_config.modalities` because depth was captured during rendering. The current public release contains **RGB only** — no `_depth.mp4` files are shipped. The depth-modality release is scheduled for a follow-up upload.
----
-## Evaluation Protocol
-The dataset ships with a two-tier protocol that any action-conditioned generator can be plugged into via a `rollout(context, actions) -> frames` interface — no retraining required.
-- **GT-anchored tier.** Pixel-level (LPIPS, PSNR) and distributional (FVD) comparison between the model's rollout and the released ground-truth video at the annotated endpoint pair. Primary tier when the model's action interface matches the 100 cm / 15° grid.
-- **Self-consistency tier.** `Inv-SC`, `Loop-SC`, `Equiv-SC` compare two rollouts of the **same** model to each other (start vs. end of `A ‖ A⁻¹`; endpoints of equivalent `A`, `B`). SC is **invariant to any uniform reparameterisation of the action space** and is therefore well-defined across frameworks with heterogeneous action interfaces (continuous keyboard-mouse vectors, dual categorical indices, pose deltas, etc.).
-The two tiers answer complementary questions — *does the rollout match reality* vs. *is the model internally coherent under composition* — and their joint movement is itself diagnostic.
-### Reference results
-Baselines reported in the companion paper, scored on the pixel-validated test set (Easy tier; see paper for exact split sizes):
-| Model | Inv PSNR ↑ | Loop PSNR ↑ | Equiv PSNR ↑ |
-|---|---|---|---|
-| Chunk-AR (~420 M, ours)   | **16.63** | **18.76** | **18.37** |
-| Matrix-Game 2.0           | 11.08     | 11.03     | 13.24     |
-| Infinite-World            | 12.55     | 12.72     | 13.23     |
-Per-relation PSNR gap of 3.4–6.0 dB between Chunk-AR and the best external baseline, with relation orderings (which of the three is hardest) re-ranking from one model to the next — a signal not predictable from FVD / LPIPS alone.
----
-## Loading
-The five zip splits unpack into flat directories of `.mp4` + `_meta.json` pairs, so the simplest loader is plain Python:
 ```python
 import json
 from glob import glob
 from pathlib import Path
-ROOT = Path("result_dataset")  # decompressed root
 def load_split(split_name):
-    """Return a list of (mp4_path, metadata_dict) tuples."""
-    out = []
     for meta_path in sorted(glob(str(ROOT / split_name / "*_meta.json"))):
         with open(meta_path, "r", encoding="utf-8") as f:
             meta = json.load(f)
-        mp4_path = meta_path.replace("_meta.json", ".mp4")
-        out.append((mp4_path, meta))
-    return out
-inv_easy   = load_split("inverse_easy")     # 246 trajectories
-inv_hard   = load_split("inverse_hard")     # 202 trajectories
-loop_easy  = load_split("loop_easy")        # 247 trajectories
-loop_hard  = load_split("loop_hard")        # 198 trajectories
-equiv_easy = load_split("equivalence_easy") # 484 trajectories = 242 (A,B) pairs
-# Reconstruct Equivalence (A, B) pairs by partner_trajectory_id
-pairs = {}
-for mp4, meta in equiv_easy:
-    pid = meta["paired_trajectory"]["primary_trajectory_id"]
-    pairs.setdefault(pid, {})[meta["paired_trajectory"]["role"]] = (mp4, meta)
-# now pairs[pid] = {"path_A": (mp4, meta), "path_B": (mp4, meta)}
-```
-Decoding the videos (any of OpenCV / `decord` / `torchvision.io.read_video` works):
-```python
-import decord  # pip install decord
-vr = decord.VideoReader(mp4_path)
-frames = vr.get_batch(range(len(vr))).asnumpy()  # (360, 720, 1280, 3) uint8
-actions = meta["action_sequence"]                # length 40
-# Frame i belongs to action floor(i / 9); per-step pose lives in meta["steps"][i // 9].
 ```
-For `datasets`-library users, a thin wrapper that yields `{video, actions, trajectory_type, paired_trajectory_id, root_state}` records is straightforward; we plan to add a `loading_script.py` in the next revision.
----
-## Intended Use & Scope
-**In scope.** Diagnostic evaluation of action-conditioned video world models on compositional consistency; relation-aware training that exploits Inverse / Loop / Equivalence as path-level supervision; identifiability studies that need a reachable subgraph with annotated state-equivalences.
-**Out of scope.** Static, single-agent, human-scale navigation under a 9-action discrete vocabulary. Dynamic subjects, physics, multi-agent interaction, and non-human-scale navigation are covered by complementary benchmarks (HM-World, MIND, WildWorld). The GT-anchored tier under pixel metrics conflates algebraic violation with per-action scale mismatch when a model's interface differs from the released grid; cross-framework claims should be anchored on the action-scale-invariant self-consistency tier.
-**Held-out from this release.** Trajectories that collided during rendering (the `random_walk/` split) and `equivalence_hard` are not included; only pixel-validated, collision-free trajectories are released here. Depth-modality `mp4` files were captured but are scheduled for a follow-up upload.
----
-## License
-Released under **CC BY 4.0**. The UE5 capture code (`AutoRenderingUE5/`) is released alongside under the same terms; please refer to the repository for any third-party scene asset licences.
 ## Citation
 ```bibtex
 @inproceedings{reasoningstructuredvideos2026,
   title  = {Reasoning-Structured Videos: A Stratified Diagnostic Suite for Compositional Consistency in World Models},
-  author = {Anonymous},
-  booktitle = {Advances in Neural Information Processing Systems (NeurIPS) Datasets and Benchmarks Track},
-  year   = {2026},
-  note   = {Under review}
 }
 ```

 # Reasoning-Structured Videos
+*Updated 17 September 2026: corrected release description and added the latest completed R20/R50 evaluations.*
+**A stratified diagnostic suite for compositional consistency in action-conditioned video world models.**
+Reasoning-Structured Videos is a deterministic Unreal Engine 5 video benchmark in which trajectories are organised as rooted graphs rather than as independent clips. The graph construction exposes three path-level relations that a faithful transition model should respect:
+- **Inverse:** execute a path and its reverse; the endpoint should return to the observed root.
+- **Loop:** follow a closed route and revisit the root state.
+- **Equivalence:** follow two distinct paths that are constructed to reach the same endpoint.
+These relations test consistency across action histories. They complement, rather than replace, conventional quality measures such as FVD, LPIPS, and PSNR: the benchmark separates reference fidelity, internal cross-path agreement, relation-specific failure, and horizon-dependent drift.
+> Companion paper: *Reasoning-Structured Videos: A Stratified Diagnostic Suite for Compositional Consistency in World Models* (NeurIPS 2026 Datasets & Benchmarks Track).
+## Dataset at a glance
 | Field | Value |
 |---|---|
 | Engine | Unreal Engine 5 |
+| Scenes | Approximately 30 indoor, outdoor, and mixed environments |
+| Modality in this release | RGB H.264 video plus JSON metadata |
+| Resolution / frame rate | 1280 × 720, 16 fps |
+| Logical trajectory | 40 actions × 9 frames/action = 360 frames (22.5 s) |
+| Action space | 9 discrete primitives: forward/backward/left/right, turn left/right, look up/down, and no-op |
+| Action grid | Translation step 100 cm; yaw step 15°; pitch step 7.5° |
+| Camera | 79° horizontal FOV, Habitat convention |
+| Released records | 1,377 RGB videos and 1,377 matching metadata JSON files |
+| License | CC BY 4.0 |
+The release contains pixel-validated, collision-free reasoning trajectories. Invalid or colliding renders are not counted in the relation-evaluation splits. Depth was captured during rendering but is not included in the current public upload; this is an RGB-only release.
+### Split counts
+| Split | Tier | Trajectories / videos | Relation units |
+|---|---:|---:|---:|
+| `inverse_easy` | Easy | 246 | 246 paths |
+| `inverse_hard` | Hard | 202 | 202 paths |
+| `loop_easy` | Easy | 247 | 247 paths |
+| `loop_hard` | Hard | 198 | 198 paths |
+| `equivalence_easy` | Easy | 484 | 242 paired graphs (A/B) |
+| **Total** |  | **1,377** | **1,135 relation units** |
+The repository stores the five splits as flat directories. Each video is paired with a `_meta.json` file. An additional `equivalence.zip` archive mirrors the Equivalence split; it is not a separate evaluation split.
+## How the trajectories are constructed
+Root states are sampled on a 200 cm XY grid with eight yaw orientations per cell and filtered using scene-geometry collision checks. The relation constructors then generate paths with explicit endpoint identities:
+- **Inverse:** a multi-step path is concatenated with its action-wise reverse and padded to the fixed horizon. Translation and rotation blocks are mixed so that the return cannot be reduced to a purely visual shortcut.
+- **Loop:** the release contains both exploration-and-return paths accepted under a documented residual tolerance and geometrically closed polygon paths (rectangle, triangle, or hexagon). The metadata records the construction branch.
+- **Equivalence:** alternative paths are generated by commutative segment shuffles or matched L-shape/zig-zag constructions. Both branches share the intended root and terminal state while differing in their intermediate histories.
+The metadata records the relation, branch or pair identifier, action sequence, root state, per-step expected and realised poses, collision mask, and render configuration. Relation labels are therefore available without reconstructing them from pixels.
+## File layout
+```text
+dataset/
 ├── inverse_easy/
+│   ├── run_<timestamp>__traj_<id>.mp4
+│   └── run_<timestamp>__traj_<id>_meta.json
 ├── inverse_hard/
 ├── loop_easy/
 ├── loop_hard/
 └── equivalence_easy/
+    ├── run_<timestamp>__pair_<pid>_A_traj_<id>.mp4
+    ├── run_<timestamp>__pair_<pid>_A_traj_<id>_meta.json
+    ├── run_<timestamp>__pair_<pid>_B_traj_<id>.mp4
+    └── run_<timestamp>__pair_<pid>_B_traj_<id>_meta.json
 ```
+For Equivalence, `pair_<pid>` identifies one graph unit and `_A_`/`_B_` identifies its two branches. The two branch trajectory IDs are consecutive.
+Each metadata file contains, among other fields:
 ```json
 {
   "trajectory_id": 353,
   "trajectory_type": "inverse",
   "total_steps": 40,
   "frames_per_step": 9,
   "total_frames": 360,
+  "root_state": {"position": [-2490.0, 1200.0, 400.0]},
+  "action_sequence": ["move_right", "turn_right", "..."],
+  "collision_mask": [0, 0, 0],
+  "render_config": {"resolution": [1280, 720], "fov": 79.0}
 }
 ```
+## Evaluation protocol
+The evaluator accepts an action-conditioned generator through a `rollout(context, controls) -> frames` interface; no retraining is required.
+**GT-anchor tier — reference fidelity.** Compare generated endpoints with the released GT endpoint using LPIPS and PSNR. This tier is most interpretable when the model's control and conditioning interface is calibrated to the benchmark.
+**Self-consistency tier — internal coherence.** Compare relation-defined endpoints produced by the same model: Inverse/Loop compare the returned endpoint with the root reference, while Equivalence compares the generated A/B endpoints. SC detects cross-history disagreement but does not by itself certify that the agreed output is the correct GT state; a constant or jointly wrong output can obtain a deceptively good agreement score. SC should therefore be read jointly with GT fidelity and motion/validity checks.
+## Reference evaluations
+The tables below summarise the latest completed evaluations associated with this release. LPIPS is lower-is-better and PSNR is higher-is-better. Values are endpoint means; the paper and evaluation artifact contain confidence intervals and per-graph records.
+### Native-interface self-consistency
+These original full-set evaluations use each model's documented native control interface. They provide broad diagnostic profiles, not a capacity-controlled universal ranking.
+| Model | Inverse LPIPS / PSNR | Loop LPIPS / PSNR | Equivalence LPIPS / PSNR |
+|---|---:|---:|---:|
+| Chunk-AR | 0.45 / 12.57 | 0.65 / 13.98 | 0.52 / 14.75 |
+| Matrix-Game 2.0 | 0.71 / 10.45 | 0.72 / 10.62 | 0.59 / 12.57 |
+| Infinite-World | 0.60 / 12.02 | 0.67 / 11.47 | 0.60 / 12.14 |
+### Common-camera R50 self-consistency
+HY-WorldPlay and minWM receive the same frozen graph IDs and camera trajectories through their official pose-control pathways. The track contains 50 graph units per relation and 200 rollout videos in total. Both models completed all 200 rollouts.
+| Model | Inverse LPIPS / PSNR | Loop LPIPS / PSNR | Equivalence LPIPS / PSNR |
+|---|---:|---:|---:|
+| HY-WorldPlay | **0.4597 / 15.07** | **0.4941 / 15.50** | **0.3723 / 16.94** |
+| minWM | 0.7118 / 10.46 | 0.7442 / 10.85 | 0.4437 / 14.05 |
+The relation-dependent gaps are informative: HY–minWM LPIPS differs by about 0.25 on Inverse/Loop but only 0.071 on Equivalence. This is a controlled common-camera comparison, but it does not equalise model capacity, training data, architecture, or memory.
+### Additional camera-trajectory R20 evaluations
+R20 contains 20 graph units per relation and 80 rollout videos per configuration because Equivalence retains both A/B branches. All rows below completed 80/80 rollouts without failures. These are configuration profiles rather than a single strict ranking: HY R20 uses 416 × 240 evaluation output, while the other rows use 512 × 288 endpoint preprocessing; SANA-WM generated at 640 × 352 and was evaluated after the common endpoint resize. Matrix-Game is shown separately because its R20 row uses native controls.
+| Configuration | Inverse LPIPS / PSNR | Loop LPIPS / PSNR | Equivalence LPIPS / PSNR |
+|---|---:|---:|---:|
+| HY-WorldPlay (R20) | 0.4038 / 16.12 | 0.4562 / 15.48 | 0.3542 / 17.37 |
+| minWM (R20) | 0.7229 / 10.46 | 0.7442 / 11.08 | 0.4227 / 14.05 |
+| MagicWorld-Base | 0.7034 / 12.44 | 0.6935 / 12.09 | 0.4486 / 16.98 |
+| MiniWorld-0.5B (LM) | 0.7287 / 11.22 | 0.7394 / 10.62 | 0.6403 / 10.85 |
+| MiniWorld-1B (server) | 0.6920 / 13.01 | 0.6997 / 12.89 | 0.4007 / 19.81 |
+| LingBot-World-v2 Light 1.3B | 0.6084 / 12.18 | 0.6568 / 11.79 | 0.5302 / 15.06 |
+| SANA-WM streaming 4-step 360P | 0.5703 / 13.34 | 0.5694 / 13.24 | 0.5778 / 13.50 |
+| Matrix-Game 2.0 (native R20) | 0.6749 / 10.50 | 0.7379 / 9.84 | 0.5658 / 12.96 |
+Useful observations are relation-specific rather than a universal ranking. Loop LPIPS is higher than Inverse in most evaluated configurations, while Equivalence can obtain a low SC distance even when both paths share an incorrect scene. The MiniWorld upgrade is a concrete example: Equivalence SC-LPIPS improves from 0.6403 to 0.4007, whereas matched GT-terminal LPIPS improves from 0.7938 to 0.7428 on the same outputs. Agreement and reference recovery are complementary axes.
+![R20 relation-resolved profiles](assets/relation_profiles.png)
+*Relation-resolved LPIPS/PSNR profiles. Native-interface and camera-trajectory tracks are separated; the figure is descriptive and should be read with the protocol notes above.*
+### GT-anchor and same-output reference audits
+The following GT-anchor runs use model-native conditioning and should be interpreted within each model because the available GT context differs.
+| Model / conditioning | Inverse LPIPS / PSNR | Loop LPIPS / PSNR | Equivalence LPIPS / PSNR |
+|---|---:|---:|---:|
+| HY-WorldPlay R50, 1 reference frame | 0.5212 / 14.15 | 0.5306 / 14.95 | 0.5820 / 13.73 |
+| minWM R50, 180 GT context frames | 0.5710 / 12.93 | 0.6195 / 12.67 | 0.5824 / 13.59 |
+| HY-WorldPlay R20, 1 reference frame | 0.4735 / 15.10 | 0.4883 / 15.21 | 0.5706 / 14.27 |
+| minWM R20, 180 GT context frames | 0.5725 / 13.27 | 0.6055 / 12.76 | 0.5746 / 13.81 |
+MiniWorld's same-output GT-terminal audit is also available for the R20 SC rollouts:
+| Configuration | Inverse LPIPS / PSNR | Loop LPIPS / PSNR | Equivalence LPIPS / PSNR |
+|---|---:|---:|---:|
+| MiniWorld-0.5B LM | 0.7281 / 11.19 | 0.7450 / 10.55 | 0.7938 / 10.04 |
+| MiniWorld-1B server | 0.6920 / 13.01 | 0.7023 / 12.86 | 0.7428 / 13.14 |
+### Endpoint FID diagnostic
+Endpoint FID is reported separately from SC because it measures proximity to the GT endpoint distribution and is sensitive to sample size and preprocessing. It should not be used as a strict cross-protocol ranking.
+| Model / protocol | Inverse | Loop | Equivalence |
+|---|---:|---:|---:|
+| Matrix-Game full set | 134.94 | 141.33 | 145.55 |
+| Matrix-Game R20 | 263.19 | 330.96 | 271.31 |
+| HY-WorldPlay R50 | 118.25 | 138.23 | 156.76 |
+| minWM R50 | 242.46 | 249.40 | 240.23 |
+| HY-WorldPlay R20 | 138.72 | 182.29 | 186.72 |
+| minWM R20 | 275.49 | 294.76 | 268.41 |
+| MagicWorld-Base R20 | 318.99 | 325.09 | 300.92 |
+## What the benchmark reveals
+The evaluation is designed to produce a capability profile rather than a single leaderboard number:
+1. **Reference fidelity and internal coherence can disagree.** Equivalence may have the best SC while having the weakest GT-anchor or Endpoint-FID result, because two generated paths can agree on a shared wrong scene.
+2. **Relation-specific failures are visible.** Return relations test recovery of an observed root; Equivalence tests agreement between alternative histories. A model that is close on one relation need not be close on another.
+3. **Long-horizon drift is measurable.** On the frozen horizon study, Matrix-Game Inverse LPIPS increases from 0.4851 at 10 actions to 0.7062 at 40 actions; minWM increases by 0.2697 LPIPS and HY-WorldPlay by 0.1039 on the corresponding R20 comparisons.
+4. **Agreement is not sufficient evidence of correctness.** SC should be paired with GT-anchor or same-output GT-terminal checks, motion checks, and visual inspection. The benchmark retains low-information outputs in aggregate rather than silently removing them.
+## Loading the data
 ```python
 import json
 from glob import glob
 from pathlib import Path
+ROOT = Path("result_dataset")
 def load_split(split_name):
+    records = []
     for meta_path in sorted(glob(str(ROOT / split_name / "*_meta.json"))):
         with open(meta_path, "r", encoding="utf-8") as f:
             meta = json.load(f)
+        records.append((meta_path.replace("_meta.json", ".mp4"), meta))
+    return records
+inverse_easy = load_split("inverse_easy")
+loop_easy = load_split("loop_easy")
+equivalence_easy = load_split("equivalence_easy")
 ```
+For Equivalence, group records using `paired_trajectory.primary_trajectory_id` and `paired_trajectory.role` (`path_A` or `path_B`). Videos can be decoded with OpenCV, `decord`, or another H.264 reader.
+## Reproducibility and evaluation code
+The companion evaluation artifact contains manifests, evaluators, fixed-seed R20/R50 subsets, model adapters, metric summaries, and saved rollout archives used for the reported results:
+- [Evaluation artifact](https://huggingface.co/datasets/VideoWorldmodel/Evaluation)
+- [Project page](https://reasoningvideo.github.io/reasoning-structured-videos/)
+Metric recomputation from saved rollouts does not require model inference. Regenerating rollouts requires the corresponding official model repository, checkpoint, environment, and GPU. Cross-model numerical comparisons should report the control protocol, context length, resolution, and whether the row is native-interface, common-camera, GT-anchor, or same-output GT-terminal.
+## Scope and limitations
+The primary setting is deterministic, static, single-agent, human-scale navigation with action-conditioned video generation. Dynamic subjects, stochastic exogenous events, non-rigid physics, multi-agent interaction, and non-human-scale navigation require synchronized state annotations or complementary benchmarks. GT-anchor pixel metrics can conflate control-scale mismatch with generation error when interfaces are not aligned; the common-camera SC track reduces this confound but does not equalise all model factors.
 ## Citation
 ```bibtex
 @inproceedings{reasoningstructuredvideos2026,
   title  = {Reasoning-Structured Videos: A Stratified Diagnostic Suite for Compositional Consistency in World Models},
+  author = {Qing, Zhongfei and Cai, Zhongang and Yang, Zhitao and Yang, Lei},
+  booktitle = {Advances in Neural Information Processing Systems (NeurIPS), Datasets and Benchmarks Track},
+  year   = {2026}
 }
 ```