File size: 9,819 Bytes
d220969 0a0af24 d220969 0a0af24 e6be785 0a0af24 e6be785 0a0af24 e6be785 0a0af24 e6be785 0a0af24 e6be785 0a0af24 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | ---
license: mit
task_categories:
- visual-question-answering
- text-generation
language:
- en
size_categories:
- 1K<n<10K
pretty_name: SimVerse
tags:
- benchmark
- multimodal
- reasoning
- spatial-reasoning
- video-understanding
- tool-use
configs:
- config_name: voi
data_files:
- split: test
path: voi/test.jsonl
- config_name: cube1
data_files:
- split: test
path: cube1/test.jsonl
- config_name: cube2
data_files:
- split: test
path: cube2/test.jsonl
- config_name: lamp
data_files:
- split: test
path: lamp/test.jsonl
- config_name: cutrope
data_files:
- split: test
path: cutrope/test.jsonl
---
# SimVerse
> ⚠️ **Anonymized for double-blind review.** This dataset is currently undergoing peer review. It is hosted under an anonymous account dedicated to the review process; the author and citation fields are deliberately unfilled. Permanent ownership and citation information will be added after the review concludes. Please do not attempt to deanonymize the maintainers of this dataset during review.
A multi-task benchmark for evaluating multimodal LLMs on **interactive simulation puzzles**. Five independent tasks that share a uniform prompt skeleton and a uniform output contract, so cross-task comparisons are meaningfully apples-to-apples.
## What's in this dataset
| Config | Records | Modality | Output |
|---|---|---|---|
| `voi` | 600 | images (target + base shapes) | shape placements |
| `cube1` | 502 | images (blank net + path) | face → patternId map |
| `cube2` | 502 | images (initial net + target) | roll direction sequence |
| `lamp` | 610 | image (arm + obstacles) | per-joint angle list |
| `cutrope` | 272 | gameplay video | text command script |
Total: **2,486** levels across 5 tasks.
## Quickstart
```python
from datasets import load_dataset
# Load one task config
ds = load_dataset("SimVer-ano/simverse2026", "lamp")
example = ds["test"][0]
# Each example is fully self-contained:
print(example["prompt"]["system"]) # 5-section system prompt text
print(example["prompt"]["user"]) # 9-section user prompt text
print(example["answer"]) # gold answer in the locked schema
print(example["images_relative_to_config"]) # paths to media (relative to this config dir)
```
The `prompt` field contains the **exact text** the original benchmark presented to models — see [`docs/PROMPT_SKELETON.md`](https://github.com/SimVer-ano/simverse2026/blob/main/docs/PROMPT_SKELETON.md) for the canonical 5-section system + 9-section user structure shared by all five tasks.
## Output contract (all five tasks)
Every task asks the model to end its reply with a single line:
```
FINAL_JSON: <one-line JSON object>
```
The JSON's schema is fixed per task (see the per-config README for shape). The dataset's `answer` field uses the **same** schema, so one JSON loader handles both model output and ground truth.
| Task | `answer` schema |
|---|---|
| `voi` | `{"placements": [{"shape", "angle", "vertex", "grid"}, ...]}` |
| `cube1` | `{"faces": {TOP: {patternId, rotation}, ...}}` |
| `cube2` | `{"directions": ["N","S","E","W", ...]}` (open-ended; engine validates) |
| `lamp` | `{"actions": [{"joint", "angle"}, ...]}` |
| `cutrope` | `{"commands": "...", "reason": "...", "confidence": 0..1}` (open-ended; simulator validates) |
## Files in each config
```
<config>/
├── test.jsonl # one JSON object per line — HF-auto-loadable
├── data/ # same records, split into per-level files (frontend-compatible)
└── images/ or videos/ # binary media referenced by the JSON
```
`cube1` and `cube2` additionally ship a `catalog.json` (the frontend's index/manifest), and `cutrope` additionally ships a `source/` mirror of the original frontend level files.
The per-record fields visible in `test.jsonl` are a superset of what's in `data/`. Two extra helper fields appear only in JSONL records:
| Field | Purpose |
|---|---|
| `__sample_id__` | The canonical level id (e.g. `"lamp-000"`, `"C123"`) — handy as a primary key. |
| `images_relative_to_config` (or `video_relative_to_config`) | Media paths rewritten to be relative to the config root, so they resolve from the `Image()` / `Video()` feature loader without further normalization. |
The original media paths inside the JSON record (e.g. `imageAssets.target` for VOI, `image_paths.blank_net_image` for cube1, `video.path` for cutrope) are preserved as the canonical task-native fields — use either depending on your loader.
## Reproducing the benchmark
Each record carries the **complete** prompt the benchmark submits to the model. To reproduce a run from scratch:
1. Read `prompt.system` and `prompt.user` from the record.
2. Attach the referenced media (image/video) using either `images_relative_to_config` or the task-native field.
3. Submit to your model with whatever multimodal protocol it accepts.
4. Extract the line starting with `FINAL_JSON:` from the reply, parse it as JSON.
5. Compare against `answer` (or invoke the per-task validator from the [SimVerse repo](https://github.com/SimVer-ano/simverse2026)).
The accompanying code at <https://github.com/SimVer-ano/simverse2026> includes the parser, validator, and runner for every config.
## Per-config details
- [`voi/README.md`](voi/README.md)
- [`cube1/README.md`](cube1/README.md)
- [`cube2/README.md`](cube2/README.md)
- [`lamp/README.md`](lamp/README.md)
- [`cutrope/README.md`](cutrope/README.md)
## Responsible-AI metadata
The full **datasheet** (Gebru et al. 2018, 7-section format) is in [`datasheet.md`](datasheet.md). The machine-readable RAI metadata is in [`croissant.json`](croissant.json) (Croissant 1.0, including the RAI extension). A human summary:
- **Data collection.** All five tasks are programmatically generated. VOI uses a polygon-rasterization XOR generator; cube1/cube2 use a Python cube-state simulator; lamp uses a forward-kinematics generator with axis-aligned obstacle placement; cutrope is built on top of the open-source [yell0wsuit/cuttherope-h5dx](https://github.com/yell0wsuit/cuttherope-h5dx) HTML5 port (MIT-licensed) by recording deterministic gameplay clips and authoring matching command scripts. **No human subjects or real-world data were involved.**
- **Annotation protocol.** Reference solutions are produced by the same generators that create each puzzle. For closed-form tasks (VOI, cube1, lamp), the answer is uniquely determined and machine-verifiable. For open-ended tasks (cube2, cutrope), the dataset's `answer` field carries one known-valid reference solution; validators run the underlying engine against the model's actual output rather than performing string equality, so multiple correct answers earn full credit.
- **Limitations.** Synthetic puzzles in fixed visual styles per task — models may learn render-style shortcuts. All prompts are English-only. cube1 includes `?` sentinel patterns when faces are under-determined; downstream uses outside the SimVerse evaluation flow may need to filter these. Reference solutions for open-ended tasks are non-unique, so simple string-match scoring is inappropriate; use the bundled engine-based validator.
- **Biases.** Each task's visual style is uniform across its records, which can bias evaluations toward render-style recognition rather than the reasoning skill the task is intended to probe. Reference solutions for open-ended tasks favor specific solution paths even when other paths are equally valid. Object-count distributions in cutrope reflect the upstream yell0wsuit corpus.
- **Personal / sensitive information.** **None.** Fully synthetic; the dataset contains no personally identifiable information, no human-subject data, and no sensitive content.
- **Intended use cases.** Held-out benchmarking of multimodal LLMs on (a) spatial-pattern reconstruction, (b) multi-step planning under physical constraints, and (c) short-horizon video-to-program inference. **Not** a held-out training set, **not** a real-world capability predictor, **not** a substitute for application-specific evaluation.
- **Social impact.** Low. Synthetic abstract puzzles unlikely to encode harmful content. Primary risk: benchmark gaming via render-style overfitting if widely adopted.
- **Maintenance.** All levels are deterministically regenerable from the generators in the accompanying code repository (linked from this card under the post-acceptance camera-ready URL). Schema changes are released as new versioned snapshots.
## NeurIPS 2026 compliance
This dataset is prepared for the [NeurIPS 2026 Datasets & Benchmarks track](https://neurips.cc/Conferences/2026/EvaluationsDatasetsHosting):
- ✅ Hosted on Hugging Face (one of the supported platforms with auto-Croissant generation)
- ✅ Croissant 1.0 metadata file at [`croissant.json`](croissant.json), with both Core and minimum-RAI fields
- ✅ Open license (MIT) declared in both the dataset card YAML and Croissant
- ✅ RAI items addressed in this README and machine-readable in `croissant.json`
- ✅ Anonymized for double-blind review (see notice above)
Reviewers can validate the Croissant file via <https://croissant.dev/validate>.
## Citation
```bibtex
@dataset{simverse_2026,
title = {SimVerse: A Multi-Task Benchmark for Multimodal Reasoning on Interactive Simulation Puzzles},
author = {<authors>},
year = {2026},
url = {https://huggingface.co/datasets/SimVer-ano/simverse2026}
}
```
## License
MIT — see [LICENSE](LICENSE).
|