File size: 5,243 Bytes
980f424 4337b56 980f424 4337b56 980f424 4337b56 980f424 | 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 | ---
license: apache-2.0
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).**
[](https://github.com/quome-cloud/openworld)
[](https://opensource.org/licenses/Apache-2.0)
[](https://github.com/quome-cloud/openworld)
[](#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
Apache 2.0 (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}
}
```
|