davidheineman/tiny-rl-refined-tasks-v4

tiny-rl refined tasks v4

HumanEval formatting repairs are available in sft_humaneval_repaired (16M) and sft_humaneval_repaired_2m (2M), with corresponding rl_envs_humaneval_repaired and rl_envs_humaneval_repaired_2m configs. Use these repaired configs for new HumanEval work. Their synthetic programs and complete few-shot documents pass syntax compilation; synthetic algorithm correctness remains unchecked. Benchmark pools and reference tests are preserved. The original configs retain the inputs used by frozen v4 experiments.

This repository retains the full 16,777,216-token datasets and adds 2,097,152-token pilots in sft_2m / rl_envs_2m under pilot-2m/. Pilot uploads preserve the original sft / rl_envs files and configurations. New API generation is unchecked apart from schema, native format, and token accounting; actual RL verifiers remain unchanged.

Pilot normalized source records are retained under pilot-2m/source/pilot-native/<task>/rows.jsonl.gz when supplied by the producer. Corpus-prefix pilots can also resolve source IDs through the full published source collections. SFT manifests pin their source-row or collection checksums.

Completed full SFT tasks: 15. Published 2M SFT pilots: 15.

Full 16M corpus

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 16,777,216 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
arithmetic	4096	256	256	23905
arithmetic_simple	4096	256	256	47534
basic_python	4096	256	256	67971
chat	472	94	212	41654
gsm8k	1138	83	150	33576
humaneval	38	7	14	25082
humaneval_docstring	38	7	14	20006
latex	4096	256	256	104747
make_sentence	4096	256	256	62202
mbpp	850	38	256	21783
mbpp_docstring	850	38	256	20059
partial_gsm8k	1138	83	150	32795
preference	472	89	212	41636
python_syntax	4096	256	256	86117
sentence_if	1428	256	256	85348

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
arithmetic	ready	16777216	95620	95620	14512005
arithmetic_simple	ready	16777216	190136	190136	12272519
basic_python	ready	16777216	271884	271884	16369569
chat	ready	16777216	734	166616	8874887
gsm8k	ready	16777216	3368	134304	8860881
humaneval	ready	16777216	95232	100277	16627316
humaneval_docstring	ready	16777216	74884	79366	16658603
latex	ready	16777216	418988	418988	16148882
make_sentence	ready	16777216	248808	248808	16404226
mbpp	ready	16777216	80736	86910	10269207
mbpp_docstring	ready	16777216	73907	79710	16658546
partial_gsm8k	ready	16777216	3371	131180	9044166
preference	ready	16777216	734	166541	8849334
python_syntax	ready	16777216	344468	344468	16260593
sentence_if	ready	16777216	2101	341392	8546968

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
arithmetic	0	not recorded	0	95620	1.000	0	0	2
arithmetic_simple	0	0	0	190136	1.000	0	0	2
basic_python	0	0	0	271884	1.000	0	0	2
chat	166614	not recorded	not recorded	166616	226.997	0	not recorded	2
gsm8k	134299	not recorded	not recorded	134304	39.876	0	not recorded	5
humaneval	100275	not recorded	not recorded	100277	1.053	0	not recorded	2
humaneval_docstring	79364	not recorded	not recorded	79366	1.060	0	not recorded	2
latex	0	0	0	418988	1.000	0	0	2
make_sentence	not recorded	not recorded	not recorded	248808	1.000	0	0	not recorded
mbpp	86908	not recorded	not recorded	86910	1.076	0	not recorded	2
mbpp_docstring	79708	not recorded	not recorded	79710	1.079	0	not recorded	2
partial_gsm8k	131176	not recorded	not recorded	131180	38.914	0	not recorded	4
preference	166539	not recorded	not recorded	166541	226.895	0	not recorded	2
python_syntax	0	not recorded	0	344468	1.000	0	0	2
sentence_if	341390	not recorded	not recorded	341392	162.490	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
arithmetic	not recorded	not recorded
arithmetic_simple	not recorded	not recorded
basic_python	not recorded	not recorded
chat	unchecked/nativeformat	not recorded
gsm8k	unchecked/nativeformat	not recorded
humaneval	unchecked/nativeformat	not recorded
humaneval_docstring	unchecked/nativeformat	not recorded
latex	not recorded	not recorded
make_sentence	unchecked/nativeformat	not recorded
mbpp	unchecked/nativeformat	not recorded
mbpp_docstring	unchecked/nativeformat	not recorded
partial_gsm8k	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded
python_syntax	not recorded	not recorded
sentence_if	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
arithmetic	4096	256	256	2996
arithmetic_simple	4096	256	256	5957
basic_python	4096	256	256	8433
chat	472	94	212	5760
gsm8k	1138	83	150	4515
humaneval	38	7	14	2734
humaneval_docstring	38	7	14	2278
latex	4096	256	256	13095
make_sentence	4096	256	256	7779
mbpp	850	38	256	2580
mbpp_docstring	850	38	256	2442
partial_gsm8k	1138	83	150	4274
preference	472	89	212	5716
python_syntax	4096	256	256	10854
sentence_if	1428	256	256	10862

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
arithmetic	ready	2097152	11984	11984	not recorded
arithmetic_simple	ready	2097152	23828	23828	not recorded
basic_python	ready	2097152	33732	33732	not recorded
chat	ready	2097152	709	23040	942887
gsm8k	ready	2097152	3320	18060	1027325
humaneval	ready	2097152	10657	10898	2081077
humaneval_docstring	ready	2097152	8529	8669	2084834
latex	ready	2097152	52380	52380	not recorded
make_sentence	ready	2097152	30680	30680	2051386
mbpp	ready	2097152	8476	10145	1238768
mbpp_docstring	ready	2097152	7768	9440	2083872
partial_gsm8k	ready	2097152	3364	17096	1087284
preference	ready	2097152	707	22864	943185
python_syntax	ready	2097152	43416	43416	not recorded
sentence_if	ready	2097152	2101	43448	1049767

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
arithmetic	not recorded	not recorded	not recorded	11984	1.000	0	not recorded	2
arithmetic_simple	not recorded	not recorded	not recorded	23828	1.000	0	not recorded	2
basic_python	not recorded	not recorded	not recorded	33732	1.000	0	not recorded	2
chat	23038	not recorded	not recorded	23040	32.496	0	not recorded	2
gsm8k	18055	not recorded	not recorded	18060	5.440	0	not recorded	5
humaneval	10896	not recorded	not recorded	10898	1.023	0	not recorded	2
humaneval_docstring	8667	not recorded	not recorded	8669	1.016	0	not recorded	2
latex	not recorded	not recorded	not recorded	52380	1.000	0	not recorded	2
make_sentence	0	not recorded	not recorded	30680	1.000	0	not recorded	2
mbpp	10143	not recorded	not recorded	10145	1.197	0	not recorded	2
mbpp_docstring	9438	not recorded	not recorded	9440	1.215	0	not recorded	2
partial_gsm8k	17092	not recorded	not recorded	17096	5.082	0	not recorded	4
preference	22862	not recorded	not recorded	22864	32.339	0	not recorded	2
python_syntax	not recorded	not recorded	not recorded	43416	1.000	0	not recorded	2
sentence_if	43446	not recorded	not recorded	43448	20.680	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
arithmetic	unchecked/nativeformat	not recorded
arithmetic_simple	unchecked/nativeformat	not recorded
basic_python	unchecked/nativeformat	not recorded
chat	unchecked/nativeformat	not recorded
gsm8k	unchecked/nativeformat	not recorded
humaneval	unchecked/nativeformat	not recorded
humaneval_docstring	unchecked/nativeformat	not recorded
latex	unchecked/nativeformat	not recorded
make_sentence	unchecked/nativeformat	not recorded
mbpp	unchecked/nativeformat	not recorded
mbpp_docstring	unchecked/nativeformat	not recorded
partial_gsm8k	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded
python_syntax	unchecked/nativeformat	not recorded
sentence_if	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_2m_v2 to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_2m_v2 to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_2m_v2", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
arithmetic	1182	231	310	13992
arithmetic_simple	1182	231	310	22222
basic_python	4096	256	256	8433
chat	472	94	212	5964
gsm8k	1795	777	1208	4988
humaneval	38	7	14	2430
humaneval_docstring	38	7	14	2263
latex	4096	256	256	13095
make_sentence	4096	256	256	7779
mbpp	850	38	256	2575
mbpp_docstring	850	38	256	2429
partial_gsm8k	1795	777	1208	5132
preference	472	89	212	6036
python_syntax	4096	256	256	10854
sentence_if	1428	256	256	10862

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
arithmetic	ready	2097152	2790	23783	not recorded
arithmetic_simple	ready	2097152	2860	2860	not recorded
basic_python	ready	2097152	33732	33732	not recorded
chat	ready	2097152	734	23856	966539
gsm8k	ready	2097152	3952	18130	not recorded
humaneval	ready	2097152	9441	9637	2083519
humaneval_docstring	ready	2097152	8446	8586	2084703
latex	ready	2097152	52380	52380	not recorded
make_sentence	ready	2097152	30680	30680	2051386
mbpp	ready	2097152	8478	10124	1239296
mbpp_docstring	ready	2097152	7711	9357	2083863
partial_gsm8k	ready	2097152	3985	18580	not recorded
preference	ready	2097152	734	24144	967223
python_syntax	ready	2097152	43416	43416	not recorded
sentence_if	ready	2097152	2101	43448	1049767

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
arithmetic	not recorded	not recorded	not recorded	55968	not recorded	32185	not recorded	2
arithmetic_simple	not recorded	not recorded	not recorded	88888	not recorded	86028	not recorded	2
basic_python	not recorded	not recorded	not recorded	33732	1.000	0	not recorded	2
chat	23854	not recorded	not recorded	23856	32.501	0	not recorded	2
gsm8k	not recorded	not recorded	not recorded	19952	not recorded	1822	not recorded	2
humaneval	9635	not recorded	not recorded	9637	1.021	0	not recorded	2
humaneval_docstring	8584	not recorded	not recorded	8586	1.017	0	not recorded	2
latex	not recorded	not recorded	not recorded	52380	1.000	0	not recorded	2
make_sentence	0	not recorded	not recorded	30680	1.000	0	not recorded	2
mbpp	10122	not recorded	not recorded	10124	1.194	0	not recorded	2
mbpp_docstring	9355	not recorded	not recorded	9357	1.213	0	not recorded	2
partial_gsm8k	not recorded	not recorded	not recorded	20528	not recorded	1948	not recorded	2
preference	24142	not recorded	not recorded	24144	32.894	0	not recorded	2
python_syntax	not recorded	not recorded	not recorded	43416	1.000	0	not recorded	2
sentence_if	43446	not recorded	not recorded	43448	20.680	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
arithmetic	verified_math	not recorded
arithmetic_simple	verified_math	not recorded
basic_python	unchecked/nativeformat	not recorded
chat	unchecked/nativeformat	not recorded
gsm8k	verified_math	not recorded
humaneval	unchecked/nativeformat	not recorded
humaneval_docstring	unchecked/nativeformat	not recorded
latex	unchecked/nativeformat	not recorded
make_sentence	unchecked/nativeformat	not recorded
mbpp	unchecked/nativeformat	not recorded
mbpp_docstring	unchecked/nativeformat	not recorded
partial_gsm8k	verified_math	not recorded
preference	unchecked/nativeformat	not recorded
python_syntax	unchecked/nativeformat	not recorded
sentence_if	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_content_endings_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_content_endings_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_content_endings_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	1756	231	197	9405
preference	1756	231	197	9405

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	2097152	856	37620	993551
preference	ready	2097152	856	37620	993551

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	37620	not recorded	not recorded	37620	43.949	0	not recorded	2
preference	37620	not recorded	not recorded	37620	43.949	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_native_diverse_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_native_diverse_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_native_diverse_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	472	94	212	3235
preference	472	89	212	3235

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	2097152	7284	12921	1520253
preference	ready	2097152	7284	12921	1520253

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	12919	not recorded	not recorded	12921	1.774	0	not recorded	2
preference	12919	not recorded	not recorded	12921	1.774	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

Full 16M corpus

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_elementary_noun to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 16,777,216 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_elementary_noun to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_elementary_noun", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	1024	256	256	92452
preference	1024	256	256	92452

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	16777216	1024	369808	8183829
preference	ready	16777216	1024	369808	8183829

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	369806	not recorded	not recorded	369808	361.141	0	not recorded	2
preference	369806	not recorded	not recorded	369808	361.141	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_elementary_noun_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_elementary_noun_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_elementary_noun_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	1024	256	256	11641
preference	1024	256	256	11641

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	2097152	1024	46564	1015700
preference	ready	2097152	1024	46564	1015700

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	46562	not recorded	not recorded	46564	45.473	0	not recorded	2
preference	46562	not recorded	not recorded	46564	45.473	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_elementary_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_elementary_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_elementary_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	1024	256	256	11846
preference	1024	256	256	11846

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	2097152	1024	47384	1005060
preference	ready	2097152	1024	47384	1005060

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	47382	not recorded	not recorded	47384	46.273	0	not recorded	2
preference	47382	not recorded	not recorded	47384	46.273	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

Full 16M corpus

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_native_diverse to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 16,777,216 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_native_diverse to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_native_diverse", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	472	94	212	25398
preference	472	89	212	25398

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	16777216	29730	101415	12339497
preference	ready	16777216	29730	101415	12339497

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	101413	not recorded	not recorded	101415	3.411	0	not recorded	2
preference	101413	not recorded	not recorded	101415	3.411	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_repaired_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_repaired_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_repaired_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	472	94	212	5974
preference	472	89	212	6037

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	2097152	734	23896	968482
preference	ready	2097152	734	24148	971141

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	23894	not recorded	not recorded	23896	32.556	0	not recorded	2
preference	24146	not recorded	not recorded	24148	32.899	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_diverse_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_diverse_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_diverse_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	1772	233	198	11202
preference	1772	233	198	11202

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	2097152	9716	44808	1077813
preference	ready	2097152	9716	44808	1077813

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	44808	not recorded	not recorded	44808	4.612	0	not recorded	2
preference	44808	not recorded	not recorded	44808	4.612	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_chat_dpo_short_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_chat_dpo_short_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_chat_dpo_short_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
chat	1772	233	198	9244
preference	1772	233	198	9244

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
chat	ready	2097152	856	36976	1012357
preference	ready	2097152	856	36976	1012357

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
chat	36976	not recorded	not recorded	36976	43.196	0	not recorded	2
preference	36976	not recorded	not recorded	36976	43.196	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
chat	unchecked/nativeformat	not recorded
preference	unchecked/nativeformat	not recorded

HumanEval format repair: Full 16M corpus

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_humaneval_repaired to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 16,777,216 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_humaneval_repaired to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_humaneval_repaired", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
humaneval	38	7	14	20672
humaneval_docstring	38	7	14	19680

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
humaneval	ready	16777216	78564	82461	16654086
humaneval_docstring	ready	16777216	73590	77966	16661432

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
humaneval	82459	not recorded	not recorded	82461	1.050	0	not recorded	2
humaneval_docstring	77964	not recorded	not recorded	77966	1.059	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
humaneval	unchecked/nativeformat	not recorded
humaneval_docstring	unchecked/nativeformat	not recorded

HumanEval format repair: 2M pilot

Native task data for the v4 study. Tasks arrive independently as their frozen pools and SFT corpora finish.

Select sft_humaneval_repaired_2m to inspect few-shot training documents. The text field is the actual native model input; each document has 2–4 examples, GPT-2 token counts, and no added system message or chat control tokens. Each completed task in this configuration has 2,097,152 usable input prediction tokens. The last document remains complete; budget_tokens specifies its usable prefix. This is a training-token budget, not a count of newly generated unique tokens. Repeated task instructions, source questions, and frozen demonstrations also contribute tokens. The audit below distinguishes source identities, source/reference variants, and stored example occurrences. Diversity counts describe complete stored documents; any unused tail of the final document lies outside the training budget.

Select rl_envs_humaneval_repaired_2m to inspect every frozen source at all sixteen hint levels. train comes from the RL fold, validation from development, and test from the held-out test fold. prompt is the exact few-shot input, completion is the withheld reference suffix, and prefix + completion reconstructs full_reference. Training samples the missing-token count uniformly from 1 through 16. These rows describe environments, not policy rollouts.

The sixteen-level hint checks apply to actual frozen RL targets and demonstrations. New API SFT generation uses unchecked/nativeformat: schema, native text format, and token accounting are checked; generated code tests and mathematical answers are not executed or semantically validated. Historical full_sft code corpora checked complete-program tests, protected prefixes, and docstrings, while incomplete-prefix rejection is not required. SFT-only generated documents are not inserted into RL or demonstration pools. Manifests and row provenance record the generation and validation scopes.

tests, demonstrations, keywords, baseline, provenance, completion_ids, and SFT source_ids are JSON strings to keep a stable browser schema across tasks. Full references and rejected comparison replies are included for manual inspection. Actual rewards use the frozen task verifier; exact string matching is not a replacement.

Formats follow functional_rl.v2: math uses its reasoning/answer or answer-trace format; code and syntax tasks use native program text; LaTeX and text continuation remain native; Chat/DPO use their user/assistant text fields. No uniform chat wrapper is inserted around task-native documents.

Source groups are disjoint across SFT, RL, calibration, development, and test. Frozen SFT demonstrations may appear in held-out prompts. Raw normalized pools, source snapshots, provenance, and checksums are available under raw/, provenance/, and manifests/. Calibration is retained in the raw data rather than merged into RL.

Fresh expanded SFT source/reference collections are under source/fresh-native-v1/<task>/variants.jsonl.gz; these normalized rows resolve synthetic and procedural SFT source IDs absent from the original raw pools. Make Sentence retains its expanded normalized SFT pool under raw/make_sentence/sft.jsonl.gz and its verbatim web collection and source manifest under source/make_sentence-v2/. SFT manifests pin collection hashes. Synthetic coding rows explicitly identify teacher-generated tests; unchecked generation does not run these tests. Historical test execution is weaker evidence than independent upstream benchmark tests. Exact contract/program hash exclusion does not establish semantic independence from held-out tasks.

HumanEval and Basic Skills are hinted study adaptations with their declared source-group folds; their held-out folds are not the standard unmodified benchmark evaluation. Source licenses remain those of the datasets identified in each task manifest.

Both browser configurations have a task column for filtering. For example, load load_dataset("davidheineman/tiny-rl-refined-tasks-v4", "sft_humaneval_repaired_2m", split="train") and select dataset.filter(lambda row: row["task"] == "mbpp"). The native text is preserved exactly in Parquet.

Task	RL sources	Development sources	Test sources	SFT documents
humaneval	38	7	14	2430
humaneval_docstring	38	7	14	2263

SFT quality audit: held rows describe a local candidate withheld from the SFT configuration; ready rows accompany the published corpus. A variant is a distinct (source_id, reference_sha256) pair. Unique reference tokens sum the reference tokens once per variant; they exclude document formatting and questions. Common text can still occur in different variants. Missing historical metrics are shown as not recorded, never inferred as zero.

Task	SFT state	Training tokens	Unique sources	Unique variants	Unique reference tokens
humaneval	ready	2097152	9441	9637	2083519
humaneval_docstring	ready	2097152	8446	8586	2084703

API teacher rows counts retained reference variants attributed to the API teacher, not API requests or all attempted outputs. Synthetic rows is the subset with newly generated coding contracts and self-generated tests, rather than new implementations of a fixed source contract. A source can have multiple different teacher variants. Mean source uses is total stored occurrences divided by unique sources; reference repeats counts occurrences beyond the first occurrence of each source/reference variant. Frozen demonstration counts are retained stored examples required to reproduce RL prompts.

Task	API teacher rows	Synthetic rows	Teacher source IDs	Total occurrences	Mean source uses	Reference repeats	Duplicate documents	Frozen demonstrations
humaneval	9635	not recorded	not recorded	9637	1.021	0	not recorded	2
humaneval_docstring	8584	not recorded	not recorded	8586	1.017	0	not recorded	2

Task	SFT code validation policy	Stored examples by validation scope
humaneval	unchecked/nativeformat	not recorded
humaneval_docstring	unchecked/nativeformat	not recorded

Clear-reference MBPP / HumanEval design pilot

Configs sft_code_clear_v1_2m and rl_envs_code_clear_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. The benchmark instructions, signatures, tests and source folds remain fixed; only implementation bodies are rewritten into ordinary clear Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Cross-fold canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-clear-v1-2m/.

Full 16M clear-reference MBPP / HumanEval development data

Configs sft_code_clear_v1_16m and rl_envs_code_clear_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. The benchmark instructions, signatures, tests and source folds remain fixed; only implementation bodies are rewritten into ordinary clear Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Cross-fold canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-clear-v1-16m/.

Balanced benchmark/synthetic MBPP / HumanEval

Configs sft_code_clear_mixed_v1_2m and rl_envs_code_clear_mixed_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. Each function draw selects benchmark versus synthetic origin with probability 0.5, then samples within that pool. All RL/evaluation source pools are byte-identical to the clear-reference data. The benchmark instructions, signatures, tests and source folds remain fixed; only implementation bodies are rewritten into ordinary clear Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Cross-fold canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-clear-mixed-v1-2m/.

Broader independently tested MBPP / HumanEval RL environments

Configs sft_code_clear_practice_v1_2m and rl_envs_code_clear_practice_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This variant retains the original clear-reference SFT bytes and adds 1,024 fresh synthetic RL contracts per task. Each new reference passes its original example and at least four independently generated edge-case assertions. RL samples missing length first, then benchmark/practice origin uniformly, then an eligible contract. New groups, questions and canonical code are excluded from the existing SFT/RL/development/test pools. Benchmark development/test bytes stay fixed. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Cross-fold canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-clear-practice-v1-2m/.

Larger native MBPP / HumanEval source bank (16m)

Configs sft_code_fresh_native_v1_16m and rl_envs_code_fresh_native_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. Function draws select authentic benchmark sources with probability 0.1, then sample within that pool. The larger bank includes unused cached API contracts and doctest-style HumanEval documentation. Source counts and actual unique-program coverage are recorded in the manifest. Its broader independently tested RL and original held-out source bytes stay fixed. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Cross-fold canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-fresh-native-v1-16m/.

Larger native MBPP / HumanEval source bank (2m)

Configs sft_code_fresh_native_v1_2m and rl_envs_code_fresh_native_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. Function draws select authentic benchmark sources with probability 0.1, then sample within that pool. The larger bank includes unused cached API contracts and doctest-style HumanEval documentation. Source counts and actual unique-program coverage are recorded in the manifest. Its broader independently tested RL and original held-out source bytes stay fixed. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-fresh-native-v1-2m/.

Combined MBPP / HumanEval training-pool RL (16m)

Configs sft_code_joint_training_v1_16m and rl_envs_code_joint_training_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. SFT and RL deliberately share original benchmark TRAINING questions in this variant. RL samples missing length uniformly first, then uniformly selects an origin: original RL benchmark, SFT benchmark, or fresh independently tested practice. All added benchmark references pass their original executable tests. Calibration/development/test are held out and byte-identical to the preceding data. This uses the same terminal16M SFT policy and KL reference without additional SFT. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-joint-training-v1-16m/.

Broader independently tested MBPP / HumanEval RL environments 16M

Configs sft_code_clear_practice_v1_16m and rl_envs_code_clear_practice_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This variant retains the original clear-reference SFT bytes and adds 1,024 fresh synthetic RL contracts per task. Each new reference passes its original example and at least four independently generated edge-case assertions. RL samples missing length first, then benchmark/practice origin uniformly, then an eligible contract. New groups, questions and canonical code are excluded from the existing SFT/RL/development/test pools. Benchmark development/test bytes stay fixed. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-clear-practice-v1-16m/.

Consistent examples and natural local names (2m)

Configs sft_code_consistent_names_v1_2m and rl_envs_code_consistent_names_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. Natural local-variable variants are applied to mbpp, humaneval_docstring. Keep the original plus at most three reversible variants, sampling source groups before styles. Signatures and statements are preserved; no artificial endings. Unselected task formats retain their source corpus. RL/calibration/development/test bytes stay fixed. Synthetic programs contradicting their existing example assertions are discarded before augmentation. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-consistent-names-v1-2m/.

Consistent examples and natural local names (16m)

Configs sft_code_consistent_names_v1_16m and rl_envs_code_consistent_names_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. Natural local-variable variants are applied to mbpp, mbpp_docstring, humaneval, humaneval_docstring. Keep the original plus at most three reversible variants, sampling source groups before styles. Signatures and statements are preserved; no artificial endings. Unselected task formats retain their source corpus. RL reuses the exact expanded independently tested benchmark/practice pool; calibration/development/test bytes stay fixed. Synthetic programs contradicting their existing example assertions are discarded before augmentation. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-consistent-names-v1-16m/.

Additional original full-MBPP sources (2m)

Configs sft_code_full_mbpp_seeds_v2_2m and rl_envs_code_full_mbpp_seeds_v2_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This revision adds 84 original full-MBPP SFT problems and 27 disjoint RL problems, rendered in each native task format. The pinned upstream revision and CC-BY-4.0 attribution are in the manifest. Every original sanitized MBPP ID and all known existing task IDs, original questions and implementations are excluded before admission. Added references pass their unchanged published tests. SFT draws body-length bands from the original authentic training distribution, then benchmark versus consistent synthetic origin at probability 0.5, then source group and natural local-name style. RL samples missing length uniformly first, then original-benchmark versus additional-MBPP origin uniformly. Original calibration/development/test bytes remain fixed; the exclusion audit is included. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-full-mbpp-seeds-v2-2m/.

Consistent examples with original names (2m)

Configs sft_code_consistent_original_v1_2m and rl_envs_code_consistent_original_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This isolates example-consistency filtering: all retained original function names, signatures and bodies are kept without identifier augmentation, and source groups are sampled before documents are packed. RL/calibration/development/test bytes are unchanged. Synthetic programs contradicting their existing example assertions are discarded before augmentation. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-consistent-original-v1-2m/.

Consistent examples with original names (16m)

Configs sft_code_consistent_original_v1_16m and rl_envs_code_consistent_original_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This isolates example-consistency filtering: all retained original function names, signatures and bodies are kept without identifier augmentation, and source groups are sampled before documents are packed. RL/calibration/development/test bytes are unchanged. Synthetic programs contradicting their existing example assertions are discarded before augmentation. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-consistent-original-v1-16m/.

Original names and balanced function lengths (2m)

Configs sft_code_balanced_original_v1_2m and rl_envs_code_balanced_original_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This revision adds 84 original full-MBPP SFT problems and 27 disjoint RL problems, rendered in each native task format. The pinned upstream revision and CC-BY-4.0 attribution are in the manifest. Every original sanitized MBPP ID and all known existing task IDs, original questions and implementations are excluded before admission. Added references pass their unchanged published tests. SFT draws body-length bands from the original authentic training distribution, then benchmark versus consistent synthetic origin at probability 0.5, then source group and an unchanged original program, without identifier augmentation. RL samples missing length uniformly first, then original-benchmark versus additional-MBPP origin uniformly. Original calibration/development/test bytes remain fixed; the exclusion audit is included. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-balanced-original-v1-2m/.

Original names and balanced function lengths (16m)

Configs sft_code_balanced_original_v1_16m and rl_envs_code_balanced_original_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This revision adds 84 original full-MBPP SFT problems and 27 disjoint RL problems, rendered in each native task format. The pinned upstream revision and CC-BY-4.0 attribution are in the manifest. Every original sanitized MBPP ID and all known existing task IDs, original questions and implementations are excluded before admission. Added references pass their unchanged published tests. SFT draws body-length bands from the original authentic training distribution, then benchmark versus consistent synthetic origin at probability 0.5, then source group and an unchanged original program, without identifier augmentation. RL samples missing length uniformly first, then original-benchmark versus additional-MBPP origin uniformly. Original calibration/development/test bytes remain fixed; the exclusion audit is included. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-balanced-original-v1-16m/.

Standalone-assertion feedback for RL (16m)

Configs sft_code_clear_practice_assertions_v1_16m and rl_envs_code_clear_practice_assertions_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This reward-only control reuses the same terminal16M SFT checkpoint and broader independently tested RL pool. A complete original test-suite pass earns1. Failing completions receive mean credit across explicit standalone assertion tests, with fresh program state per assertion; wrapped HumanEval tests keep binary rewards. If all independent assertions pass while the original complete suite fails, reward falls back to0. Reported pass@1 always runs the complete unchanged original suite. RL-only provenance declares the policy; SFT/calibration/development/test bytes and source/hint sampling remain fixed. This variant retains the original clear-reference SFT bytes and adds 1,024 fresh synthetic RL contracts per task. Each new reference passes its original example and at least four independently generated edge-case assertions. RL samples missing length first, then benchmark/practice origin uniformly, then an eligible contract. New groups, questions and canonical code are excluded from the existing SFT/RL/development/test pools. Benchmark development/test bytes stay fixed. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Synthetic SFT bodies receive syntax/context checks only. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-clear-practice-assertions-v1-16m/.

Original benchmark RL with natural local-name variation (16m)

Configs sft_code_consistent_local_rl_v1_16m and rl_envs_code_consistent_local_rl_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. RL retains the original92 MBPP /38 HumanEval source problems and adds bounded reversible local-variable names, without changing public signatures, instructions, statements or tests. Sample missing length uniformly1–16, then an eligible ORIGINAL source group uniformly, then a style uniformly; functions with more styles receive no extra problem weight. Every full gold variant passes the unchanged complete test suite once. SFT/calibration/dev/test bytes stay identical to the consistency-filtered16M parent. Training reuses that exact terminal SFT policy and KL reference with zero extra SFT. Binary complete-test-suite reward is retained. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-consistent-local-rl-v1-16m/.

Fresh short functions with 50% benchmark draws (2m)

Configs sft_code_short_functions_50p_v1_2m and rl_envs_code_short_functions_50p_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This bank adds 3,357 distinct new ordinary functions with4–32 implementation tokens and three unchanged executable examples checked once per contract. It retains the earlier original-name source bank. Native documents contain2–4 complete functions; function draws use original authentic body-length bands and benchmark-origin probability0.5, then uniform source groups. This probability describes function draws, not a token fraction. Canonical programs and normalized exact questions are excluded against the declared earlier training/RL/calibration/dev/test pools; this is not a proof of semantic novelty. Original RL and all held-out bytes remain unchanged. These are fixed-budget repacked documents, not16M unique API-generated tokens. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-short-functions-50p-v1-2m/.

Fresh short functions with 10% benchmark draws (2m)

Configs sft_code_short_functions_10p_v1_2m and rl_envs_code_short_functions_10p_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This bank adds 3,357 distinct new ordinary functions with4–32 implementation tokens and three unchanged executable examples checked once per contract. It retains the earlier original-name source bank. Native documents contain2–4 complete functions; function draws use original authentic body-length bands and benchmark-origin probability0.1, then uniform source groups. This probability describes function draws, not a token fraction. Canonical programs and normalized exact questions are excluded against the declared earlier training/RL/calibration/dev/test pools; this is not a proof of semantic novelty. Original RL and all held-out bytes remain unchanged. These are fixed-budget repacked documents, not16M unique API-generated tokens. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-short-functions-10p-v1-2m/.

Coverage-checked original-suite unit feedback (16m)

Configs sft_code_consistent_suite_units_rl_v1_16m and rl_envs_code_consistent_suite_units_rl_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This reward-only control reuses the exact consistency-filtered terminal16M SFT policy and KL reference, with zero extra SFT. It retains the original92 MBPP /38 HumanEval source groups and unchanged questions, signatures, references, tests, hint/source sampling and all SFT/held-out bytes. Full original-suite passes earn1. Failing completions can earn assertion credit inside original wrapped tests and loops only when the complete ordered assertion-ID trace matches the passing gold trace. Unsupported gold behavior, incomplete or changed coverage falls back to the binary result; an instrumented perfect score contradicting an original-suite failure earns0. Reported pass@1 always uses the unchanged complete original suite. Worker/grader hashes and per-source eligibility are recorded in unit-coverage-audit.json. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-consistent-suite-units-rl-v1-16m/.

Fresh short functions with 10% benchmark draws (16m)

Configs sft_code_short_functions_10p_v1_16m and rl_envs_code_short_functions_10p_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This bank adds 3,357 distinct new ordinary functions with4–32 implementation tokens and three unchanged executable examples checked once per contract. It retains the earlier original-name source bank. Native documents contain2–4 complete functions; function draws use original authentic body-length bands and benchmark-origin probability0.1, then uniform source groups. This probability describes function draws, not a token fraction. Canonical programs and normalized exact questions are excluded against the declared earlier training/RL/calibration/dev/test pools; this is not a proof of semantic novelty. Original RL and all held-out bytes remain unchanged. These are fixed-budget repacked documents, not16M unique API-generated tokens. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-short-functions-10p-v1-16m/.

Original canonical benchmark solutions with short-function SFT (2m)

Configs sft_code_canonical_short_v1_2m and rl_envs_code_canonical_short_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This revision restores original benchmark implementation text verbatim instead of teacher rewrites. Original questions, tests, public signatures and source-fold membership are retained before canonical-code overlap exclusions. Added full-MBPP sources already keep their upstream implementations. The preceding consistent synthetic bank and3357 fresh short source functions are reused, with restored RL/held-out canonical implementations excluded from SFT. Native documents use2–4 complete functions, body-band frequencies from authentic SFT sources only, and10% benchmark-origin function draws. This is a different completion-task definition from clear-reference variants: prefixes, target suffixes, hint eligibility and some demonstrations change. Never pair accuracy across these different task definitions. All strict SFT-versus-RL comparisons remain within this fixed definition. No reserved-test model inference has been performed. Raw pools, exclusion/restoration audit and full preflight are included. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures and tests are retained, and original implementation text is restored verbatim. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-canonical-short-v1-2m/.

Original canonical benchmark solutions with short-function SFT (16m)

Configs sft_code_canonical_short_v1_16m and rl_envs_code_canonical_short_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This revision restores original benchmark implementation text verbatim instead of teacher rewrites. Original questions, tests, public signatures and source-fold membership are retained before canonical-code overlap exclusions. Added full-MBPP sources already keep their upstream implementations. The preceding consistent synthetic bank and3357 fresh short source functions are reused, with restored RL/held-out canonical implementations excluded from SFT. Native documents use2–4 complete functions, body-band frequencies from authentic SFT sources only, and10% benchmark-origin function draws. This is a different completion-task definition from clear-reference variants: prefixes, target suffixes, hint eligibility and some demonstrations change. Never pair accuracy across these different task definitions. All strict SFT-versus-RL comparisons remain within this fixed definition. No reserved-test model inference has been performed. Raw pools, exclusion/restoration audit and full preflight are included. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures and tests are retained, and original implementation text is restored verbatim. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-canonical-short-v1-16m/.

Authentic-only SFT documents on the original-canonical task (2m)

Configs sft_code_canonical_authentic_documents_v1_2m and rl_envs_code_canonical_authentic_documents_v1_2m cover all four plain/docstring tasks. Each task has exactly 2,097,152 SFT input predictions in native few-shot documents. This SFT-source-composition control trains on original authentic benchmark functions only, sampled uniformly by source group. No synthetic function appears in any training document. The preceding complete raw source bank is included to preserve frozen few-shot contexts; available raw sources are distinct from sampled document sources. RL/calibration/dev/test prompts, implementations, tests and hint/source sampling remain byte-identical to the original-canonical parent. Original programs are retained verbatim. The authentic-document audit lists every eligible source and actual document coverage. Same32M30TPP base, initialization, optimizer, ending weights and budgets as the parent; no new teacher calls. Synthetic programs contradicting their existing example assertions are discarded before packing. Each unique contract is checked once across formats. Original expected values and benchmark tests are never rewritten. This establishes example consistency, not complete semantic correctness. Rejection counts and source IDs are in the manifest. Original benchmark instructions, signatures and tests are retained, and original implementation text is restored verbatim. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-canonical-authentic-documents-v1-2m/.

Selected MBPP and HumanEval development data (16m)

Configs sft_code_refined_mbpp_humaneval_v1_16m and rl_envs_code_refined_mbpp_humaneval_v1_16m cover all four plain/docstring tasks. Each task has exactly 16,777,216 SFT input predictions in native few-shot documents. This combines the recorded development candidates:32M MBPP/MBPP Docstring use consistency-filtered original-name SFT and original-source-group-balanced local-name RL;64M HumanEval/HumanEval Docstring use original-name/body-balanced SFT and original-plus-extra-MBPP RL. Missing length is uniform1–16 and all reported correctness uses the unchanged complete original test suite. Benchmark implementation bodies retain the recorded gold-test-checked clear rewrites, with original question/contracts/signatures/tests/folds. Evaluation temperature0.2 is shared across tasks; training rollouts use temperature1, recorded separately in the manifest. HumanEval RL-seed replication and reserved-test validation are pending; these are selected development data, not a validated release claim. Actual training configurations include the declared one-time function-changing QK/projection initialization controls, with ordinary updates afterward. All selected saved development prompts were reconstructed and matched byte-for-byte. Per-task source manifests retain their pinned upstream and license attribution, and training-sources.json links the original public snapshots and exact full-budget runs. Original benchmark instructions, signatures, tests and source folds remain fixed; clear-reference bodies use ordinary Python. A rewrite failing the unchanged benchmark tests retains its original implementation. Held-out canonical implementations are excluded from training; uniform missing lengths 1–16 select eligible functions without padding. These are development data, and useful SFT accuracy and RL improvement are still being tested. Raw pools, complete documents, manifests and code are under code-refined-mbpp-humaneval-v1-16m/.