--- license: cc-by-4.0 task_categories: - video-classification - other language: - en tags: - world-model - video-generation - action-conditioned - unreal-engine-5 - compositional-reasoning - benchmark pretty_name: Reasoning-Structured Videos size_categories: - 1K 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___traj_.mp4 # RGB rollout, 360 frames │ └── run___traj__meta.json # actions, root state, per-step pose, relation ├── inverse_hard/ │ └── ... ├── loop_easy/ │ └── ... ├── loop_hard/ │ └── ... └── equivalence_easy/ ├── run___pair__A_traj_.mp4 # path A ├── run___pair__A_traj__meta.json ├── run___pair__B_traj_.mp4 # path B (paired) └── run___pair__B_traj__meta.json ``` ### Filename schema - **Single-trajectory splits** (`*_easy` for Inverse / Loop, `*_hard`): `run___traj_.mp4` paired with `..._meta.json`. - **Equivalence pairs**: `run___pair___traj_.mp4` — the `pair_` 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} } ```