| --- |
| license: cc-by-4.0 |
| language: |
| - en |
| task_categories: |
| - question-answering |
| - text-generation |
| tags: |
| - code |
| - python |
| - code-tracing |
| - program-execution |
| - synthetic |
| size_categories: |
| - 10K<n<100K |
| --- |
| |
| # code_trace: execution-verified Python tracing questions |
| |
| Each document shows a short piece of Python (one function plus the helpers, constants and classes it needs) and asks a |
| question about what happens when one specific call runs. Every answer was obtained by running that exact code in a sandbox. |
| |
| The questions, answers and worked traces are produced by deterministic code from recorded executions; no language model |
| wrote or checked any question, answer or trace. The Python source code itself is ALEA's own synthetic code written by |
| language models: GLM-5.3-Flash, DeepSeek-V4.1-Flash and Qwen3.8 for the OpenLemma modules, gpt-6-luna for the R3 functions, |
| and OpenAI Codex agents for the code library. |
| |
| ## Question kinds |
| |
| - **final_output**: what a call returns (as a Python repr) or prints. |
| - **var_at_line**: the value of a named local variable just before a marked line runs for the k-th time. |
| - **loop_state**: the values of one or two variables after the body of a marked loop has completed N passes (stated as |
| "just before pass N+1 begins"), or how many times the loop body runs. |
| - **exception**: whether the call raises, and if so which exception class; otherwise the returned value. |
| - **return_type**: the type name of the returned value, asked on a version of the code with parameter / return annotations, |
| local variable annotations and docstrings removed. |
| - **call_count**: how many times a helper or recursive function is called during the call. |
| |
| Minimal pairs: many questions come in twins that share the code and differ in one element of the input (input twins), or |
| share the input and differ in one token of the code, such as `<` vs `<=` or a constant (code twins), with different answers. |
| Functions whose return type depends on the branch taken contribute type twins. About 29% of the documents show a short |
| step-by-step trace (line-by-line variable updates, per-pass loop values or the list of calls, all copied from the recorded |
| execution) before a final `Answer:` line; the same questions also appear elsewhere with the answer only. About 5% of the |
| documents start with one or two solved examples from other code. Documents are rendered as plain instructions, Q/A pairs or |
| chat turns. |
| |
| ## Source code |
| |
| ALEA's own synthetic Python code from three pools: verified function modules with tests from the OpenLemma code collection |
| (excluding every item that matches the OpenLemma held-out evaluation set), verified single functions with assertion checks |
| from the KL3M R3 verified-code collection, and larger tested modules from ALEA's synthetic code library (from which only the |
| self-contained functions are cut out, at most about 80 lines with their dependencies). Only the Python standard library is |
| used. |
| |
| ## How the answers were made |
| |
| 1. Each code unit's own tests were run in an isolated sandbox (no network, no file system access outside a temporary |
| directory, memory and time limits) with a profiler that records the arguments of calls to the unit's functions. |
| 2. Those recorded arguments were changed by one edit at a time (a number up or down, a list element dropped, duplicated or |
| swapped, a string character changed, an empty value) to make new inputs; a second edit of an edited input gives the |
| input twins. The original test inputs are used only for the trace-state kinds, never for final-output questions. |
| 3. Every call was executed in the sandbox under a line tracer, on the cut-out snippet and on the full original module (the |
| two must agree), at two hash seeds (the two must agree). Answers with memory addresses, unordered sets of strings, very |
| long floats or long output were dropped. |
| 4. Every document was then re-executed independently (plain evaluation, a counting wrapper for call counts, and an inserted |
| recording statement for line and loop questions) at six hash seeds; any function unit with a disagreement was removed. |
| |
| ## Surface-cue controls |
| |
| Exception answers are balanced between "raises" and "returns" overall (1,752 raise / 1,794 return), within each function, and within |
| groups defined by whether the code contains a `raise` statement and whether the input contains an empty, zero or negative |
| value. Call-count, iteration-count and return-type answers are capped per value. A classifier that sees only the question |
| text, or only the call, was trained with cross-validation grouped by code unit; documents it could answer from the call |
| text alone were removed for the exception and return-type kinds until its gain over the majority answer was below 4 |
| points. On the released documents the largest gain of any question-only or call-only classifier over the majority answer is 4.8 points. |
| |
| ## Counts |
| |
| | kind | docs | sw32k tokens | |
| |---|---:|---:| |
| | final_output | 8,173 | 2,476,007 | |
| | var_at_line | 5,154 | 1,860,750 | |
| | loop_state | 4,358 | 1,530,879 | |
| | exception | 3,546 | 1,259,301 | |
| | return_type | 1,621 | 404,657 | |
| | call_count | 1,290 | 578,933 | |
| | **total** | **24,142** | **8,110,527** | |
| |
| | code pool | docs | share | |
| |---|---:|---:| |
| | OpenLemma verified code modules | 9,532 | 39.5% | |
| | synthetic code library modules | 8,901 | 36.9% | |
| | R3 verified functions | 5,709 | 23.6% | |
| |
| 3,914 code units, 5,354 function units; no topic or skill above 4.4% of documents. Presentations: qa 7,352, chat 7,113, plain 9,677. |
| |
| ## Review |
| |
| Before release, every document was re-executed by independent drivers at six hash seeds, and any function unit with a |
| disagreement was removed (about 0.07% of executions disagreed, all from unordered-set iteration or helper call paths). We |
| traced 34 documents by hand (all correct) and re-ran 12 encoded documents in the sandbox (all matching); the cosmetic issues |
| found (a duplicated word in one loop template, a doubled answer label, sign artifacts such as `-0` in edited inputs, and |
| local variable annotations that revealed return types) were fixed before encoding. An independent blind review of 60 |
| documents, 30 of them re-executed, found 1 ambiguous call-count question about a generator function (a generator's body is |
| re-entered on every resume). As a result, all call-count questions about generator functions were removed, together with |
| line-state questions whose answer only repeats an unchanged argument; the remaining notes were minor style points. The texts |
| were screened for overlap with ALEA's evaluation sets and held-out probes, and documents sharing a 13-word span with the |
| OpenLemma held-out evaluation code were removed. |
| |
