Datasets:
license: cc-by-4.0
language:
- en
tags:
- code
- python
- program-comprehension
- synthetic
- execution-verified
pretty_name: ALEA code_comprehend
size_categories:
- 10K<n<100K
ALEA code_comprehend
Execution-verified Python code-comprehension tasks built from the ALEA Institute's own synthetic code. Each document shows real, runnable code and asks a question whose answer was obtained by running that code in a sandbox. The set was built for midtraining a small language model. It teaches reasoning about what code does when one line changes, rather than writing code.
Tasks
| kind | question | answer |
|---|---|---|
failing_test |
A module, 4 to 8 short tests and a one-line edit (shown as a diff, a line-number change or a prose edit). Which tests fail after the edit? A single-test variant asks whether one named test still passes. | test names in listing order, or none / yes / no |
edit_output |
A module, a call and its current result, and a one-line edit. What does the call return after the edit? | the Python repr of the value, or raises <Exception> |
fill_line |
Code with one line removed, a few tests, and 3 or 4 candidate lines. Which candidate makes every test pass? | a letter |
spot_bug |
A specification (a natural-language request, or the docstring plus tests), numbered code that may contain a one-line bug, and tests. Which line is wrong and what should it be? | line N: <corrected line> or no bug |
About 28% of rows are worked: they give a short, step-by-step account before a final Answer: line. Every value
stated in a worked row comes from the execution record. This includes how often the edited line ran, which way a
condition went, the values a variable took, and what a call returned before and after the edit. Many worked rows have
a direct-answer twin elsewhere in the set. About 7% of rows start with one or two solved demonstrations taken from
other code units, and a demonstration's answer never equals the target's answer. Rows come in three presentations:
plain instruction, a Q/A frame, or a chat turn. The instruction always comes before the code.
How the gold was produced
- Code. The code comes from three ALEA synthetic pools:
- verified OpenLemma v0.5 code records, each a module with two independent test suites, written by GLM-5.3-Flash, DeepSeek-V4.1-Flash and Qwen3.8 and verified by execution;
- functions from ALEA's verified-code set (R3), written by gpt-6-luna;
- functions sliced from the ALEA synthetic-code corpus, written by OpenAI Codex agents, each re-executed alone and checked to give results identical to the full module.
- Mutations. Edits are single-line, single-node changes made in the code's own formatting:
- comparison or arithmetic operator swaps;
- off-by-one constants that already occur in the module;
- boolean flips and
and/orswaps; - adding or removing a negation;
min/max-style call swaps;- a wrong variable from the same function;
- slice bounds.
- Execution. All execution ran inside a bubblewrap sandbox: no network, a read-only interpreter, a fresh temporary directory, memory, CPU and time limits, and an audit hook that refuses subprocesses and sockets. Every case ran under two hash seeds, and anything whose result differed between them was dropped. Answers containing memory addresses, very long float reprs, sets of strings or timing were dropped.
- failing_test. The original code passes every shown test, and the failing set is the observed set.
- fill_line. Exactly one option passes every shown test (expected values are compared with
==semantics, and only values that can be written in a test are used). Most rows ask for the original line. About 18% are twins with the same code and options whose tests come from executing a comparison, constant or arithmetic alternative; each fill_line row says that the tests, not the names or docstrings, define correctness. - spot_bug. Each buggy version fails at least one shown test. Every unit also has a clean twin, the same unit with no bug, which passes all of them. The tests are introduced neutrally ("The tests describe the intended behavior"), never as already passing.
- Worked traces. When the edited line itself raises, the worked text says so instead of reporting a condition value. Variable values are listed as the sequence of changes (runs that leave a value unchanged are not repeated), and the text says so.
- Shown tests. Duplicate tests and tests with constant-true assertions are not shown.
- Independent re-execution. Every training row was rebuilt from its code and answer and re-run in a fresh sandbox; 16,852 of 16,855 agreed and the 3 others were removed. After the last template changes, all 13,990 failing_test, spot_bug and edit_output rows were re-run again and all agreed.
- LLM use in this build. A language model wrote no row text and no answers. For the R3 verified-code functions,
which had no stored tests, gpt-6-luna (OpenAI, flex tier) proposed only input call expressions such as
f([1, 2], 3). Every expected value was then produced by executing the function in the sandbox. Calls were parsed, restricted to literal arguments, and kept only when they ran deterministically.
Cue controls
Baselines were measured with a 5-fold, code-unit-grouped logistic regression on cue-only inputs. All of them are within about 5 points of the prior:
- failing_test, edit plus test name per test: +3.8 points;
- failing_test, position only: +0;
- edit_output, "unchanged" predicted from the question alone: +1.6;
- fill_line, options only: +1.9 (character and word n-grams), after an out-of-fold adversarial filter that removed fill_line units whose answer the options-only model could pick;
- spot_bug, telling the mutated line from the original line: -0.1;
- spot_bug, ranking the bug line among the unit's mutable lines from line text alone: +2.9.
Several measures went into this:
- answer letters, bug-line positions and the number of failing tests are balanced;
- "none", "unchanged" and "no bug" answers make up 18 to 39% of their kinds;
- test names are neutral (
test_1,check_a, ...) in about half of the rows that come from suites with descriptive names; - three kinds of mutation were excluded from spot_bug because their direction gives them away: removing a negation,
adding a negation, and flipping
+=/-=; - spot_bug pairs whose mutation an out-of-fold classifier could recognise, and fill_line units whose correct option an options-only classifier could pick, were dropped as whole groups.
Counts (encoded training rows)
| rows | sw32k tokens | |
|---|---|---|
| total | 15,419 | 10.81M |
| OpenLemma v0.5 code | 6,163 (40.0%) | 5.41M |
| R3 verified functions | 6,011 (39.0%) | 3.09M |
| synthetic-code snippets | 3,245 (21.0%) | 2.31M |
By kind: spot_bug 4,804 (no bug 1,875), failing_test 4,632, edit_output 4,305, fill_line 1,678. The rows come from 4,344 distinct code units in 350 strata (skills / categories / topics), and no stratum exceeds 5%. Two pools exceed 30% (at most 40%) because the synthetic-code pool is small. Rows are a mean of 701 tokens long, with a maximum of 3,074. A held-out probe split of about 1.5% of code units is kept separately and is not part of the training rows.
Decontamination
Rows were screened against ALEA evaluation references and sibling families' held-out sets at the 8- and 13-gram level. Rows that shared a 13-gram with OpenLemma's held-out evaluation code were removed, apart from widely shared idioms. Any code unit whose id or normalised code matched that evaluation set had already been excluded before generation.
Review
We read 32 rows ourselves and re-executed every training row independently in the sandbox. Two blind reviews followed:
- Blind review 1 (60 rows): 1 HARD, a false premise (a spot_bug prompt said the tests already pass on code that fails one). It was fixed for every row. Its style notes on unnatural fill_line tests led to restricting and filtering that kind.
- Blind review 2 (60 new rows; the reviewer executed all 60, and every answer was correct): 1 HARD, a worked trace that collapsed repeated values into a misleading sequence. The trace wording was fixed for every row. Minor style notes (duplicate or filler tests, an unsuitable system line, two lead-in phrasings) were also addressed.
License
CC BY 4.0. The code is synthetic and was written for ALEA. Any names that appear in it are invented.