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

*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.