README.md

---
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<n<10K
---

# 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}
}
```