code_trace: 24142 train rows

README.md

@@ -0,0 +1,108 @@
+---
+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.

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8de19cee53cc0b273bc53e3abc941e4e0dfa7d88a83ea6d5bdb8c0292166b5c0
+size 8865006