Create README.md

README.md

@@ -0,0 +1,160 @@
+---
+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:
+  - 10K<n<100K
+---
+
+# 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^{-1}}\!\circ T_A(s_0)=s_0$ &nbsp; — a path followed by its reverse returns to the start.
+- **Loop** &nbsp; $T_A(s_0)=s_0$ &nbsp; — a topologically closed action sequence closes in state space.
+- **Equivalence** &nbsp; $T_A(s_0)=T_B(s_0),\ A\ne 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 |
+| Modalities | RGB (mp4) + Scene Depth (16-bit PNG / mp4) + per-frame action labels + relation metadata |
+| 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) |
+| Aggregate footage | ≈ 250 h rendered, ~40 K candidate trajectories before filtering |
+| Released splits (Layer-1 valid) | **Inverse 8,936 · Equivalence 8,937 · Loop 672** |
+| Pixel-validated subset (Layer-2 pass) | Inverse 3,440 · Equivalence 3,556 · Loop 254 |
+
+---
+
+## 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 \in \{10,\ldots,20\}$) interleaves translation blocks and rotation blocks, then is concatenated with its action-wise reverse $A^{-1}$ 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^m V^n$ vs. **zig-zag** $(UV)^k U^{m-k} V^{n-k}$ pairs ($m,n \in [3,6]$) with self-inverse rotation pairs filling remaining slots, sharing only origin and terminus with disjoint interiors.
+
+A two-layer pixel-level validator certifies that every released relation holds to MSE tolerance on the captured frames; trajectories whose realised pose deviates from the expected pose by > 1 cm at any step are routed to a held-out **`random_walk/`** split and excluded from consistency-metric evaluation.
+
+### Deterministic capture pipeline
+
+To make the rendering function $g\colon \mathcal{S}\to\mathcal{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, 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.
+
+---
+
+## Directory Layout
+
+```
+reasoning-structured-videos/
+├── inverse/
+│   ├── run_<TIMESTAMP>__traj_<ID>.mp4              # RGB rollout, 360 frames
+│   ├── run_<TIMESTAMP>__traj_<ID>_depth.mp4        # 16-bit scene depth
+│   └── run_<TIMESTAMP>__traj_<ID>_meta.json        # actions, root state, relation, collision mask
+├── loop/
+│   └── ...
+├── equivalence/
+│   ├── run_<TIMESTAMP>__traj_<ID>.mp4              # path A
+│   ├── run_<TIMESTAMP>__traj_<ID+1>.mp4            # path B (paired)
+│   └── ...
+├── random_walk/                                     # held-out: pose deviation > 1 cm
+└── filter_summary.json                              # per-type counts and Layer-2 MSE statistics
+```
+
+Each `_meta.json` records `trajectory_type`, `paired_trajectory` (for Equivalence's $A,B$ pairs), the full `action_sequence`, the `root_state`, `collision_mask`, render configuration, and the algebraic identity asserted by the trajectory.
+
+---
+
+## 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^{-1}$; 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 Layer-2 pixel-validated test set (see paper for exact splits):
+
+| 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
+
+```python
+from datasets import load_dataset
+
+# entire dataset
+ds = load_dataset("<org>/reasoning-structured-videos")
+
+# single relation
+inv = load_dataset("<org>/reasoning-structured-videos", split="inverse")
+loop = load_dataset("<org>/reasoning-structured-videos", split="loop")
+equiv = load_dataset("<org>/reasoning-structured-videos", split="equivalence")
+
+sample = inv[0]
+# sample["video"]:           360 RGB frames (1280×720)
+# sample["depth"]:            360 16-bit depth frames, normalised to 100 m
+# sample["actions"]:          list of 40 discrete actions
+# sample["trajectory_type"]:  "inverse" | "loop" | "equivalence"
+# sample["paired_trajectory_id"]: int | null (only set for equivalence)
+# sample["root_state"]:       {position: [x,y,z], rotation: [pitch,yaw,roll]}
+```
+
+Equivalence pairs are linked by `paired_trajectory_id`; iterating over the split with grouping on this field yields the $(A,B)$ pairs directly.
+
+---
+
+## 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.
+
+---
+
+## 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.
+
+