Update README.md

README.md

@@ -14,7 +14,7 @@ tags:
   - benchmark
 pretty_name: Reasoning-Structured Videos
 size_categories:
-  - 10K<n<100K
+  - 1K<n<10K
 ---
 
 # Reasoning-Structured Videos
@@ -39,15 +39,28 @@ These are *across-path* properties invisible to any single-rollout metric (FVD,
 |---|---|
 | 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 |
+| 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) |
-| 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 |
+| 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.
 
 ---
 
@@ -59,13 +72,22 @@ For each scene, root states are sampled on a 200 cm XY grid with 8 yaw orientati
 - **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.
 
-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.
+### Easy tier vs. Hard tier
+
+The paper distinguishes two tiers per relation (paper §3.2, §4.3):
 
-### Deterministic capture pipeline
+- **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, clamped auto-exposure;
+- 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.
@@ -74,25 +96,93 @@ These settings are pinned in `DataCollector.h` / `DataCollector.cpp` of the rend
 
 ---
 
-## Directory Layout
+## File Layout
+
+The release ships as five zip files. After decompression:
 
 ```
-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/
+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/
 │   └── ...
-├── equivalence/
-│   ├── run_<TIMESTAMP>__traj_<ID>.mp4              # path A
-│   ├── run_<TIMESTAMP>__traj_<ID+1>.mp4            # path B (paired)
+├── loop_easy/
 │   └── ...
-├── random_walk/                                     # held-out: pose deviation > 1 cm
-└── filter_summary.json                              # per-type counts and Layer-2 MSE statistics
+├── 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"
+}
 ```
 
-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.
+> **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.
 
 ---
 
@@ -107,7 +197,7 @@ The two tiers answer complementary questions — *does the rollout match reality
 
 ### Reference results
 
-Baselines reported in the companion paper, scored on the Layer-2 pixel-validated test set (see paper for exact splits):
+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 ↑ |
 |---|---|---|---|
@@ -121,27 +211,50 @@ Per-relation PSNR gap of 3.4–6.0 dB between Chunk-AR and the best external bas
 
 ## Loading
 
+The five zip splits unpack into flat directories of `.mp4` + `_meta.json` pairs, so the simplest loader is plain Python:
+
 ```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]}
+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)}
 ```
 
-Equivalence pairs are linked by `paired_trajectory_id`; iterating over the split with grouping on this field yields the `(A, B)` pairs directly.
+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.
 
 ---
 
@@ -151,10 +264,22 @@ Equivalence pairs are linked by `paired_trajectory_id`; iterating over the split
 
 **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}
+}
+```