README.md

metadata

license: cc-by-4.0
task_categories:
  - text-generation
language:
  - en
tags:
  - decompilation
  - python
  - bytecode
  - code
  - mbpp
size_categories:
  - n<1K
configs:
  - config_name: default
    data_files: bench.jsonl

Data card — MBPP held-out decompilation benchmark

383 MBPP reference solutions compiled to Python 3.12 bytecode and paired with their source, with the original task_id restored on every row. Built 2026-08-04 by tools/build_mbpp_ood.py.

Redistributable under CC-BY-4.0, provided NOTICES.md ships alongside.

---

The set

Rows	383 (400 candidates − 17 contaminated)
Source	google-research-datasets/mbpp, config full
Licence	CC-BY-4.0
task_id restored	383 / 383 (all distinct, range 11–973)
Untraceable rows dropped	0
Contaminated rows dropped	17 (see below)
Disassembly length	mean 47.5 lines, median 41, max 187
Python	3.12, optimize=0

In what sense this set is independent of training — stated precisely, not as an adjective

It is a different corpus (google-research-datasets/mbpp, not codeparrot/github-code-clean) and a different kind of code: short, self-contained, hand-written answers to stated problems, against the training trunk's real project code with its framework coupling and helper chains. Both differences are verifiable from row provenance.

That matters because the pilot's failure mode was a model learning the source of the data rather than the task, and a test set drawn from the training source cannot detect it.

It is not described as out-of-distribution anywhere, and no divergence statistic was computed, so no distributional-shift claim is made. The defensible claim is exactly three things: different source, different task style, and the verified non-overlap below.

Contamination — the defect that cost 17 rows

This set was originally decontaminated against the wrong corpus. build_ood_mbpp.py checked against the v1-era 10k training labels, but the shipping model (v3) trained on 48,196 rows. Re-checked against the corpus v3 actually trained on:

gate	result
exact canonical match vs v3 corpus	0 / 400
identifier-blind fingerprint vs v3 corpus	17 / 400 (4.25%)

Those 17 are dropped. They are structural collisions rather than copied code — the fingerprint erases literals, so re.sub(' +', ' ', t) and re.sub('[- ()]', '', s) collide despite computing different things. The gate is applied anyway: it is the same gate build_final.py and the CSN builder apply, and arguing with it case by case is precisely how the earlier provenance defects happened.

After rebuild: 0 / 383 contamination against the v3 corpus, by either gate.

Task ids restored

build_ood_mbpp.py wrote only {input, expected}, so no row could be traced to its task, prompt or tests. Recovery is exact rather than approximate: expected == canonicalise(mbpp["code"]), a deterministic transform, so rebuilding the map over all 974 MBPP rows (974 rows → 965 distinct canonical forms) recovers the id by lookup. All 400 rows matched; the builder refuses to emit a row it cannot trace.

Each row now carries provenance.task_id, mbpp_split, the task prompt, and the test_list. The tests travel with the row, so a behavioural check is possible on this set without going back to the dataset.

Decontamination

Two stages. At original build time, against the 10k training labels of that era, by exact canonical match and by identifier-blind fingerprint (which caught 15 items exact match missed). At rebuild, against the 48,196-row corpus the shipping model actually trained on, removing a further 17 rows as above. Rows not adjudicable by the differential-execution oracle were excluded at original build time, so every row here was labelled by running it.

Changes made to the original, as CC-BY-4.0 §3(a)(1)(B) requires be indicated

Each reference solution was rewritten through ast.unparse — normalising away formatting, comments and redundant parentheses — then compiled to a .pyc at optimize=0 and paired with a disassembly of the resulting code object. Task text and tests are unmodified.

That rewrite changes the compiled bytecode on 1 of the 383 rows. CPython 3.12 inlines comprehensions (PEP 709) and emits a cleanup entry in the exception table for the inlined scope; how the comprehension is line-wrapped changes that entry. In src/00117.py (MBPP task_id 757) the original solution wraps a nested comprehension across lines, so its bytecode differs from the normalised form shipped here. The instruction stream co_code is identical on all 383 rows; this row differs only in that exception-table entry.

The row is a valid decompilation task and the benchmark remains sound: for all 383 rows the reference source and the .pyc are compiled from the same normalised string, which is the condition the oracle needs. What the row is not is byte-identical to upstream MBPP — hence this note. Re-deriving it from the original would put that solution's tab continuations and trailing whitespace into the reference and make the label an unstable target, so it is documented instead. Measured with tools/measure_format_ceiling.py; the general limit is in ../../EVAL.md §6.

Harness soundness on this set

grade.py --self-test-only: pre-flight 383/383 = 100%, mutation kill rate 199/199 = 100%, 0 survivors. Note what pre-flight does and does not prove — see ../../ORACLE-LIMITS.md.

Read this before quoting any "OOD" figure

The published PyBytecode figures labelled OOD-MBPP — 91.04% strict greedy, 97.49% certified@32, 100% docstring recovery — were not measured on this set. They were measured on the superseded held-out set (n=279), which despite its name contains no MBPP at all: it is GitHub source from the held-out shards of the training corpus. Matching all 974 canonicalised MBPP rows against it yields 0 hits, against 400/400 for this set. Evidence in ../../LICENSING-DETERMINATION.md §4.

Those numbers remain valid measurements of held-out generalisation. They are not out-of-distribution measurements, and the label should be corrected wherever it appears.

No scores have been measured on this benchmark. Doing so requires a generation run (GPU).

Limitations

• MBPP solutions are short and stylistically uniform. Success here says little about long or framework-coupled functions; the CSN set is the harder distribution.
• Rows are the first 400 adjudicable MBPP tasks in split order, minus the 17 contaminated ones. Not a random sample.
• Two MBPP tasks with identical canonical solutions collapse to one row; 974 rows yield 965 distinct canonical forms, and the first task_id wins.

Attribution

MBPP (Mostly Basic Python Problems), Austin et al., 2021, Google Research. https://huggingface.co/datasets/google-research-datasets/mbpp — CC-BY-4.0 (https://creativecommons.org/licenses/by/4.0/).