Add branded dataset card

README.md

@@ -0,0 +1,128 @@
+---
+license: mit
+pretty_name: "OpenWorld · Coding Worlds (World-Time Compute)"
+task_categories:
+  - text-generation
+  - other
+tags:
+  - world-models
+  - world-time-compute
+  - code-generation
+  - program-synthesis
+  - reproducibility
+  - synthetic
+size_categories:
+  - n<1K
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: sft_train.jsonl
+      - split: test
+        path: test_tasks.jsonl
+  - config_name: tasks
+    data_files: tasks.jsonl
+language:
+  - en
+---
+
+# OpenWorld · Coding Worlds (World-Time Compute)
+
+**A family of **verified coding worlds** — a function to implement plus a test-suite oracle — for the *world-time-compute* realism check: fine-tune on many worlds, generalize to held-out tasks (and HumanEval/MBPP).**
+
+[![Built with OpenWorld](https://img.shields.io/badge/built%20with-OpenWorld-0f766e.svg)](https://github.com/quome-cloud/openworld)
+[![License: MIT](https://img.shields.io/badge/License-MIT-1d4ed8.svg)](https://opensource.org/licenses/MIT)
+[![Paper: World-time compute](https://img.shields.io/badge/paper-world--time%20compute-b45309.svg)](https://github.com/quome-cloud/openworld)
+[![Oracle: test suites](https://img.shields.io/badge/oracle-executable%20tests-brightgreen.svg)](#what-it-is)
+
+## Load it
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("Quome/openworld-coding")            # sft train/test
+# tasks = load_dataset("Quome/openworld-coding", "tasks")  # all 219 verified tasks
+```
+
+---
+
+A family of **verified coding worlds** — function-implementation tasks, each a world whose
+**oracle is its test suite** — for the world-time-compute realism check on a *different* use
+case than diagnosis (OpenWorld experiment E77; paper §"World-time compute").
+
+## What it is
+
+Each task is a tiny verified-code world: a function to implement (prompt = signature +
+docstring) and a set of `assert`-based unit tests that define correctness. A solution is
+"right" iff it passes **all** tests — the cleanest possible oracle (this is the
+HumanEval/MBPP setup). The transferable skill is *coding*; held-out tasks measure
+generalization.
+
+## Provenance
+
+Tasks are **LLM-authored** (Gemini 2.5 Flash) across 12 topics (strings, arrays, dicts,
+math, recursion, sorting, parsing, matrices, intervals, stacks/queues, greedy, simple DP),
+then **verified in a sandboxed subprocess** — the reference solution must pass its own tests
+before the task is admitted (~58% of generated candidates passed verification and were
+kept). This contrasts with the synthetic-parametric `openworld-diagnosis` family: here the
+worlds are *authored by a model* (the "Claude-Code-style" realism check), and the oracle is
+executable tests rather than a Bayes-optimal classifier.
+
+## Contents (JSONL)
+
+| File | Rows | Schema |
+|---|---|---|
+| `tasks.jsonl` | 219 | `{name, topic, prompt, solution, tests[]}` (all verified) |
+| `sft_train.jsonl` | 164 | `{prompt, completion}` — `prompt` = instruction + signature/docstring; `completion` = reference solution |
+| `test_tasks.jsonl` | 55 | `{id, prompt, tests[], kind}` — held-out tasks for pass@k |
+
+Task-level (world-level) train/test split: the 55 test tasks are held out from fine-tuning.
+
+## How to use
+
+Fine-tune on `sft_train.jsonl`; evaluate **pass@1 / pass@k** on `test_tasks.jsonl` (run the
+model's code against each task's `tests` in a sandbox). For real-benchmark transfer, also
+evaluate on **HumanEval / MBPP** (fetched by `experiments/e77_gen.py`'s benchmark step;
+adapters in `experiments/e77_eval.py`).
+
+## Reproduce
+
+```
+python experiments/e77_gen.py     # author + verify tasks (needs GEMINI_API_KEY in .env)
+python experiments/e77_data.py    # split + SFT
+```
+Generation uses an LLM, so the exact task set is not bit-reproducible (unlike the seeded
+diagnosis family); the committed `tasks.jsonl` is the canonical set used in E77.
+
+## Results (E77, paper §world-time compute)
+
+`experiments/results/e77_coding.json`. Headline: world-time compute helps **in-domain
+pass@k at every model size** (e.g. 7B pass@5 0.84→0.95) and transfers **positively to
+HumanEval at pass@5** (7B 0.866→0.909) from just 164 worlds — though it *hurts* greedy
+pass@1 on HumanEval. Consistent with E76's world-count law (more worlds → more gain), 164
+is below the threshold where transfer becomes strong.
+
+## License
+
+MIT (same as the OpenWorld repository). Tasks/tests are LLM-generated; treated as synthetic.
+
+
+---
+
+## From the OpenWorld project
+
+This dataset is produced by **OpenWorld** — a framework for *verified symbolic world models*, where a world's dynamics are explicit, auditable Python code (no training, no GPU). "World-time compute" is the idea that **traversing many verified worlds** of a domain and fine-tuning on that experience makes a model generalize to **unseen** worlds from fewer real examples.
+
+- 💻 **Code, experiments & paper:** https://github.com/quome-cloud/openworld
+
+## Citation
+
+```bibtex
+@software{openworld_coding_2026,
+  title  = {OpenWorld · Coding Worlds (World-Time Compute)},
+  author = {Schwoebel, Jim},
+  year   = {2026},
+  url    = {https://github.com/quome-cloud/openworld},
+  note   = {Hugging Face dataset: Quome/openworld-coding}
+}
+```