VideoWorldmodel/ReasoningStructureTestset

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   T_{A⁻¹} ∘ T_A(s₀) = s₀   — a path followed by its reverse returns to the start.
• Loop   T_A(s₀) = s₀   — a topologically closed action sequence closes in state space.
• Equivalence   T_A(s₀) = T_B(s₀), A ≠ B   — 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_IDs are always consecutive.

_meta.json schema (key fields)

{
  "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:

"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:

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):

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

@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}
}