viai957/proofforge-goedel8b-e2e-attested-generations

ProofForge e2e attested generations

This dataset holds 7,803 Lean 4 proof attempts that Goedel-LM/Goedel-Prover-V2-8B wrote for 980 statements from the Goedel-Pset-v1 training pool. A frozen Lean verifier labelled every attempt, so each row comes with its verdict. Every stored prompt was re-tokenized and compared token by token with the prompt the model actually received. All 7,803 matched. The ProofForge end-to-end smoke run of 2026-10-26 built its SFT and DPO data from these rows.

Part of the ProofForge experiment archive. This card describes the data only. The checkpoints trained on it have their own cards (section 10).

1. TL;DR

What it is	Single-round, verifier-labelled proof samples (prompt, full completion, extracted Lean code, token ids, sampling settings, verdict)
Generator	Goedel-LM/Goedel-Prover-V2-8B @ dfd02e6271a58375dfbf3ece0175277cf6b6a89a (Qwen3-8B architecture), round 0
Sampling	temperature 1.0, top-p 0.95, top-k off, n = 8 per statement, 16,384-token completion cap, vLLM 0.26.0, TP = 4
Statements	980 Goedel-Pset-v1 training-pool statements (from viai957/lean-prover-data:problems/train_pool.jsonl)
Size	7,803 generations (305 MB JSONL) + 7,803 verdicts (5.3 MB JSONL); 38.1 M completion tokens
Labels	pf_strict policy, Lean v4.9.0-rc1, Mathlib d1d1e4b7, 180 s budget, kernel re-check, axiom whitelist {propext, Quot.sound, Classical.choice}
Label mix	4,007 valid (51.4%) / 3,533 rejected (45.3%) / 263 masked (3.4%)
Coverage	571 of 980 statements (58.3%) have at least 1 valid proof; 373 have 8/8 valid (375 have every sample valid)
Base-model pass@k on this pool	pass@1 51.2% [48.3, 54.1], pass@8 58.6% [55.5, 61.7] (95% CI). Masked rows count as failures. This is a training pool, not a benchmark.
Prompt attestation	7,803 checked, 0 mismatches
Contamination	0 hits on all 16 protected sets on file (miniF2F test and valid, ProofNet, PutnamBench, MOBench and 11 others)
Compute	Generation: 49,712 s (13.8 h) wall on 4x NVIDIA L4, 797 tok/s end to end. Verification: 102,528 worker-seconds (8 Lean workers).
Downstream use	e2e SFT (320 valid proofs, 80 steps) and DPO (69 pairs, 20 steps) LoRA smoke runs on Goedel-Prover-V2-8B
Status	Superseded on 2026-10-29: the project moved to Nemotron-3-Nano and Lean v4.35

2. Dataset details and mechanism

• Curated by: viai957 (ProofForge project).
• Language: English natural-language problem text and proof plans, plus Lean 4 code.
• Licence: Apache-2.0 (section 10).
• Rounds: round 0 only. No correction or self-repair rounds are included.

flowchart LR
  A["viai957/lean-prover-data<br/>problems/train_pool.jsonl<br/>2,000 Goedel-Pset-v1 statements"] --> B["vLLM 0.26 · TP=4 · 4x L4<br/>Goedel-Prover-V2-8B @dfd02e6<br/>T=1.0, top-p 0.95, n=8, cap 16,384"]
  B --> C["gen_r0.jsonl<br/>8,082 samples<br/>(session ended early: crash)"]
  C --> D["Lean verifier pf_strict<br/>v4.9.0-rc1 · Mathlib d1d1e4b7<br/>180 s · kernel recheck · axiom whitelist"]
  D --> E["ver_r0.jsonl<br/>7,987 verdicts"]
  C --> F{"attest_shim.py<br/>drop not-in-pool (184)<br/>drop no-verdict (95)<br/>re-tokenize prompt"}
  E --> F
  F --> G["gens.attested.jsonl<br/>7,803 rows · 0 prompt mismatches"]
  E --> H["verdicts.pf_strict.jsonl<br/>7,803 rows"]
  G --> I["e2e SFT mix (320)"]
  G --> J["e2e DPO mix (96 → 69 pairs)"]
  H --> I
  H --> J

The verifier's verdict has three values. valid means Lean accepted the proof, the kernel re-check passed and only whitelisted axioms were used. rejected means the attempt failed deterministically: a compile error, no extractable code, or sorry or another banned construct. masked means the verifier did not reach a verdict (timeout, out of memory, or a crash). A masked row is neither positive nor negative, and ProofForge never uses one as a negative.

3. Data

3.1 Sources

source	role	licence	size used
Goedel-LM/Goedel-Pset-v1 via viai957/lean-prover-data problems/train_pool.jsonl	formal statements (Lean 4) and informal problem text	none declared on the HF card (Goedel-Prover code repo is MIT); informal problems from NuminaMath, Apache-2.0	980 of the 2,000-statement pool
Goedel-LM/Goedel-Prover-V2-8B	generator	Apache-2.0	revision dfd02e6271a58375dfbf3ece0175277cf6b6a89a

Why 980 statements and not 2,000: the generation session (lean_gen.py, session 1791951209-4193267) ran from 2026-10-14 09:43 to 23:32 IST. It ended in a crash after writing 8,082 samples, with 160 requests still in flight. The archived data covers the statements that were finished at that point. 969 of the 980 statements have all 8 samples. The rest have 1 to 7 (table 3.4).

3.2 Filtering and decontamination

step	rows in	rows out	evidence
raw generations (gen_r0.jsonl)		8,082	generation manifest samples_written
drop rows whose problem is not in the ProofForge e2e pool	8,082	7,898	attestation manifest drop_not_in_pool: 184
drop rows without a verifier verdict	7,898	7,803	attestation manifest drop_no_verdict: 95
prompt attestation (re-render with tokenizer, compare prompt_ids)	7,803	7,803	rows_checked: 7803, rows_mismatched: 0

Figure 0. Row counts from raw generation to the e2e SFT and DPO mixes (log scale). Sources: generation manifest, attestation manifest, ProofForge/data/e2e/2026.10.26/proofs.json, docs/evidence/p4_e2e_2026-10-26/preference_set.MANIFEST.json.

The ProofForge e2e pool was built from the 2,000-statement source pool. 8 statements were dropped for informal-text overlap with a protected set, 6 by the decontamination gate (miniF2F test and valid, MOBench), 1 by an excluded-id rule, and 24 by a float-numeral filter, leaving 1,961 statements (pool/problemset.json). This is why 184 generated rows fell outside the pool.

On 2026-11-03 every row was re-scanned with proofforge/data/blocklist.py against all 16 protected sets on file: clever, dafnybench, fate-h, fate-m, fate-x, flteval, minif2f-test, minif2f-valid, mobench, proofnet, putnambench, reform-dafnycomp, swebench-verified, verina, verinalite and verinaplus. Result: 0 hard hits and 0 weak overlaps in 7,803 rows (artifacts/hf_archive/blocklist_scan.json). One pool statement (Goedel-Pset-1349070) overlaps PutnamBench putnam_1987_b5 by natural-language window. No row in this dataset uses it.

3.3 Schema

generations config (data/gens.attested.jsonl, one generation per row)

field	type	description
problem_id	str	Goedel-Pset id, e.g. Goedel-Pset-619485
sample_idx	int	0..7, sample index within the statement
round	int	always 0
cap_tokens	int	always 16,384
prompt_ids, completion_ids	list[int]	exact token ids (Qwen3 tokenizer of the generator)
prompt_text, completion_text	str	decoded prompt (chat-templated) and completion
messages	list[dict]	the single user turn before templating
lean_code	str	Lean code extracted from the last code block of the completion
lean_code_error	str or null	extraction error; null on 7,630 rows, no_code_block 153, proof_theorem_not_found 20. This is separate from the verifier's no_code tag (443 rows, exactly the finish_reason == length rows)
finish_reason	str	stop (7,360) or length (443)
model_path, model_rev	str	generator snapshot and revision
sampling	dict	temperature, top_p, top_k, n, max_tokens, per-request seed
context_clipped	bool	always false
parent	null	reserved for correction rounds (none here)

verdicts config (data/verdicts.pf_strict.jsonl), joined to generations on key = [problem_id, sample_idx, round, cap_tokens]

field	description
verdict	valid / rejected / masked
kind	finer class: valid, invalid, timeout, infra, crash
accepted	bool, true iff verdict == valid
reasons	list of tags, e.g. compile_error, no_code, banned:sorry, timeout, memory
axioms	axioms the accepted proof depends on
budget_s, timeout_class	180.0, train180
kernel_recheck	true on all rows
policy, verifier_hash, pins_config_hash, F	verifier identity (single value on all rows)
code_sha256, row_id, stage	content hash of the checked code, row id, and the verifier stage the row reached (e.g. skipped, compile, repl, audit)

Example (abridged), generations row Goedel-Pset-619485, sample 4:

prompt_text: <|im_start|>user\nComplete the following Lean 4 code:\n\n```lean4\nimport Mathlib\nimport Aesop\n
  set_option maxHeartbeats 0\nopen BigOperators Real Nat Topology Rat\n
  /-The number \( C \) is defined as the sum of all the positive integers \( n \) such that \( n-6 \) is the
  second largest factor of \( n \). What is the value of \( 11C \)?-/
  theorem lean_workbook_51472 :\n  11 * (7 + 9 + 12) = 308  := by sorry```\n\nBefore producing the Lean 4 code ...
  provide a detailed proof plan ...
lean_code (tail):
  theorem lean_workbook_51472 :
    11 * (7 + 9 + 12) = 308  := by
    have h_main : 11 * (7 + 9 + 12) = 308 := by
      norm_num
      <;> rfl
    exact h_main
finish_reason: stop   prompt tokens: 190   completion tokens: 556

The matching verdict: {"verdict": "valid", "kind": "valid", "accepted": true, "axioms": ["propext"], "budget_s": 180.0, "kernel_recheck": true, "policy": "pf_strict"}.

A rejected verdict: {"key": ["Goedel-Pset-1599045", 0, 0, 16384], "verdict": "rejected", "kind": "invalid", "reasons": ["compile_error"], "axioms": null}.

3.4 Splits and statistics

There is a single train split per config, because every statement comes from the Goedel-Pset-v1 training pool. Do not use this data as an evaluation set.

statistic	value
rows (each config)	7,803
statements	980
samples per statement	8 for 969 statements; 7 (2), 6 (4), 4 (2), 2 (2), 1 (1)
verdicts	valid 4,007 · rejected 3,533 · masked 263
kind	valid 4,007 · invalid 3,533 · timeout 223 · infra (memory) 29 · crash 11
reason tags	compile_error 3,007 · no_code 443 · timeout 223 · banned:sorry 83 · memory 29 · crash 11 · banned:meta_api:Lean 1 · target_missing 1 (one row, Goedel-Pset-1482028 sample 4, carries three tags: banned:sorry, banned:meta_api:Lean, target_missing)
axioms in accepted proofs	propext 3,827 · Quot.sound 3,460 · Classical.choice 3,196 (of 4,007)
finish_reason	stop 7,360 · length 443. All 443 cap hits are rejected / no_code. None is masked.
prompt tokens	mean 262, median 245, p10 168, p90 359, max 1,230
completion tokens	mean 4,883, median 3,160, p10 945, p90 11,734, max 16,384; total 38,099,556
completion tokens, valid	mean 2,090, median 1,615, p90 3,899
completion tokens, rejected	mean 7,766, median 6,772, p90 16,384
completion tokens, masked	mean 8,699, median 8,600, p90 13,707
verify time per row, valid	median 1.24 s, p90 7.48 s, max 174.6 s
verify time per row, rejected	median 2.71 s, p90 34.0 s
verify time per row, masked	median 180.3 s (timeouts at the 180 s budget)

Figure 1. Left: verifier kind per row; verdict in brackets. Right: reason tags on non-valid rows (log scale). Source: data/verdicts.pf_strict.jsonl (local copy ProofForge/data/e2e/2026.10.26/sidecars/sidecars/0ee6fcb0.../pf_strict/verdicts.jsonl, sha256 d86ce61d...).

Figure 2. Number of valid proofs per statement. 409 statements have none, 373 have 8/8 valid, and 198 fall in between (1 to 7). The middle band is where group-relative RL gets a learning signal. Source: verdicts joined to generations.

Figure 3. Completion length (len(completion_ids)) by verdict. Valid proofs are short (median 1,615 tokens). The spike at the 16,384-token cap is the 443 truncated, rejected rows. Source: data/gens.attested.jsonl + verdicts.

Figure 4. Lean verification wall time per row, as an ECDF. Masked timeouts (223 of 263) sit at the 180 s budget; the 40 memory and crash rows end earlier (from 16 s). 443 rejected rows (12.5%) have a recorded time of 0 s, meaning they never reached Lean. The count equals the number of no_code tags; values below 0.01 s are drawn at 0.01 s. Source: verify_s in align/.tmp/p2/r1/pool/ver_r0.jsonl (the upstream verifier file; this field is not in the published verdicts file), joined on key.

Figure 5. Unbiased pass@k estimator (Chen et al., 2021) averaged over statements with n ≥ k samples. Masked rows count as failures. Error bars are 95% normal-approximation CIs over statements. Source: verdicts joined to generations. This measures the base model on its own training pool, not on a benchmark.

4. Procedure

4.1 Generation

Each statement was rendered with Goedel-Prover-V2's prompt (prompt_format: goedel): the Lean header, the informal problem as a comment, the formal statement ending in := by sorry, and a request for a proof plan before the code. The model's chat template was applied. Then n = 8 independent samples were drawn per statement:

$$y^{(i)}\sim {\pi }_{{\theta }_0}(\cdot \mid x),i=\mathrm{1..8},T=1.0,\text{ top-}p=0.95,\mathrm{\mid }y\mathrm{\mid }\le \mathrm{16,384}y^\{(i)\}\; \backslash sim\; \backslash pi\_\{\backslash theta\_0\}(\backslash cdot\; \backslash mid\; x),\backslash quad\; i=1..8,\backslash quad\; T=1.0,\backslash \; \backslash text\{top-\}p=0.95,\backslash \; |y|\backslash le\; 16\{,\}384$$

Engine: align/extras/vllm_rollout/lean_gen.py, vLLM 0.26.0, torch 2.11.0+cu130, tensor parallel 4, max_model_len 40,960, max_num_seqs 128, gpu_memory_utilization 0.82, KV cache 405,120 tokens, seed 0 (per-request seeds are stored in sampling.seed). The tokenizer round-trip was checked on 4 rows at start-up.

4.2 Verification (labelling)

Verifier config: statement_mode: strict, allow_helper_defs: false, lexical_gate: true, max_code_chars: 200000, proof_timeout_s: 180, 8 workers. Pins: Lean leanprover/lean4:v4.9.0-rc1, Mathlib d1d1e4b72c6e009edd97cabe1d661b021fe8eeae, REPL v4.9.0-rc1 @ 7df77c0a. Verifier hash f1dd9e78..., pins hash 00c37786....

4.3 Attestation

proofforge/e2e/attest_shim.py (commit 72e9dfa) re-renders each row's round-0 prompt in align/.venv-rollout (transformers 5.19.0). It then asserts prompt_ids == tokenizer.encode(rendered_prompt) and drops rows that cannot be joined. Output: prompt_render_sha256 = 83d0bbb9..., file sha256 1951f443... (identical to the HF LFS object).

4.4 Downstream training that consumed this data (e2e smoke, 2026-10-26)

These runs exist to show that the data plumbing works end to end. They are not attempts to improve the model. All of them used LoRA r = 64, α = 128, dropout 0, targets q/k/v/o/gate/up/down, on a frozen bf16 base, with 4x L4 FSDP (dp_shard 4), one sequence per GPU per micro-step, and AdamW (β = 0.9, 0.999, wd 0). The schedule was 3% linear warmup then cosine to 0, with grad clip 1.0.

SFT mix. Of the 4,007 valid rows, 27 were dropped because the proof rewrote the theorem statement (drop_statement_not_faithful). From the remaining 3,980, 320 rows (234 statements) were drawn as a seeded subset (seed 20261025). Objective: token-level cross-entropy on completion tokens only, with prompt tokens masked by labels_from_prompt_len. The sum is normalized by the global count of supervised tokens $N$ in the step's window across all ranks:

DPO mix. 347 eligible (valid, rejected) pairs of the same statement, 96 selected (83 statements), and 69 left after dropping 27 whose prompt plus the longer completion exceeded 8,192 tokens. Pairs are dropped, never truncated. The reference log-probs were precomputed once (ref_logps.json) from the SFT adapter, which also initializes the policy. Loss per pair, with β = 0.1:

$$\mathrm{\ell }=-\log \sigma \left(\beta \right[(\log {\pi }_{\theta }(y_w\mathrm{\mid }x)-\log {\pi }_{\text{ref}}(y_w\mathrm{\mid }x))-(\log {\pi }_{\theta }(y_l\mathrm{\mid }x)-\log {\pi }_{\text{ref}}(y_l\mathrm{\mid }x))\left]\right),{\mathcal{L}}_{\text{DPO}}=\frac{1}{N_{\text{pairs}}}\sum \mathrm{\ell }\backslash ell=-\backslash log\backslash sigma\backslash Big(\backslash beta\backslash big[(\backslash log\backslash pi\_\backslash theta(y\_w|x)-\backslash log\backslash pi\_\{\backslash text\{ref\}\}(y\_w|x))-(\backslash log\backslash pi\_\backslash theta(y\_l|x)-\backslash log\backslash pi\_\{\backslash text\{ref\}\}(y\_l|x))\backslash big]\backslash Big),\backslash qquad\; \backslash mathcal\{L\}\_\{\backslash text\{DPO\}\}=\backslash frac\{1\}\{N\_\{\backslash text\{pairs\}\}\}\backslash sum\; \backslash ell$$

hyperparameter	SFT	DPO
rows / pairs	320 rows	69 pairs
steps	80 (1 epoch, 4 rows per step)	20 (80 pair-slots, about 1.16 epochs)
peak LR	2e-5	2e-5
warmup / schedule	3% / cosine to 0	3% / cosine to 0
β	n/a	0.1
max length	seq_target 18,432	8,192 (prompt + max(chosen, rejected))
micro-batch × world × accum	1 × 4 × 1	1 × 4 × 1
grad clip	1.0	1.0
precision / attention	bf16 / SDPA (flash-attn not installed)	bf16 / SDPA
supervised units	656,910 tokens	80 pairs
wall time	1,243.4 s	881.8 s
code commit	50453074	186238f8
trainable tensors moved	504/504, base unchanged	504/504, base unchanged

The RLVR stage of the same smoke run (CISPO, 2 iterations × 8 prompts × group size 4) drew its 16 prompts from the e2e pool, not from these generations. It is documented on the checkpoints card.

5. Training curves (downstream, from real logs)

Figure 6. e2e SFT on 320 valid proofs from this dataset. loss_local is rank 0's contribution to the global token-normalized loss, so it is roughly 1/4 of the mean CE. It moves between 0.011 and 0.146 with no trend (step 1: 0.0305, step 80: 0.0333), which fits training on the model's own samples. Pre-clip grad norm stays between 0.041 and 0.092, below the 1.0 clip. Source: ProofForge/runs/pf-e2e-sft-20261026/metrics.jsonl.

Figure 7. e2e DPO on 69 pairs. loss_local is rank 0's per-pair loss divided by the 4 pairs in the window. At step 1 it equals ln 2 / 4 = 0.1733 (logged 0.17329), confirming that the policy equals the reference at initialization. Step 20: 0.139. Pre-clip grad norm is 7.0 to 14.6, so every step was clipped to 1.0. Source: ProofForge/runs/pf-e2e-dpo-20261026/metrics.jsonl.

Reward, KL and accuracy curves: not measured for these SFT and DPO runs. The loop logs loss, LR, grad norm and elapsed time only.

6. Evaluation

measurement	n	value	source
prompt attestation mismatches	7,803	0	attestation manifest
protected-set hard hits (16 sets)	7,803	0	blocklist_scan.json
statements with ≥ 1 valid proof	980	571 (58.3%)	verdicts
base-model pass@1 on this pool	980 statements	51.2% [48.3, 54.1]	verdicts, unbiased estimator
base-model pass@4 on this pool	977 statements	57.0% [54.0, 60.1]	verdicts
base-model pass@8 on this pool	969 statements	58.6% [55.5, 61.7]	verdicts
sample-level valid rate	7,803	51.4%	verdicts
SFT / DPO checkpoint benchmark scores		not measured in the e2e smoke run (the evidence gate checks plumbing, not accuracy)	p4_e2e_2026-10-26/evidence.log

Baseline, for context only (different set, not this data). The same base model and sampling settings at a 16k cap reached miniF2F-test pass@8 = 78.7% (192/244) and pass@1 = 62.1% [57.0, 67.3] (P2 baseline, 2026-10-13). On this pool pass@8 is lower (58.6%) than on miniF2F-test (78.7%) under the same sampling and 180 s verifier, though the two use different problem sets and subsets (969 vs 244 statements). Source: p2_runs/r1_baseline/ver_minif2f_c16384.jsonl (rlhf workspace).

Hill climbing: not applicable. This is a single round-0 sampling pass, with no iterations to plot.

7. Discussion, negative results and lessons

• Correction to the earlier card. The previous README said the 263 masked rows were "timeouts and truncations". The verdict file says otherwise: masked = 223 timeouts + 29 out-of-memory + 11 REPL crashes. The 443 cap-truncated completions are labelled rejected (no_code), so a pairing step that takes rejected rows as negatives can use them. The e2e protocol runs with mask_truncated_completions: false. If you do not want truncation to count as failure, filter on finish_reason == "length".
• The 180 s budget hides some solvable rows. Goedel-Prover-V2's own compile harness uses 300 s. Some of the 223 timeouts may be valid proofs, so pass@k here is a lower bound under the stricter budget.
• Statement fidelity. 27 valid proofs changed the theorem statement and were excluded from training mixes (drop_statement_not_faithful). The verdict file still marks them valid. Re-check the statement before you use valid rows as positives.
• Formal vs informal mismatch in Goedel-Pset. Some formal statements are much weaker than the informal problem they come from. In the example in section 3.3, the informal problem asks for $11C$, while the formal theorem only checks 11 * (7 + 9 + 12) = 308. A valid verdict certifies the formal statement only.
• Truncated generation run. The session crashed with 160 requests in flight, leaving 980 of 2,000 statements covered. Statement coverage is therefore set by generation order, not by random sampling.
• Downstream merge parity failed. The SFT adapter trained on this data failed the bf16 merged-vs-unmerged parity check: max |Δlogit| 9.37 against a limit of 0.05, greedy agreement 99.457% against 99.5%. Use the adapters unmerged. This concerns the checkpoints, not the data.

8. Intended use, limitations and risks

Intended: SFT on verified proofs, preference pairs (valid vs rejected for the same statement), RL difficulty filtering (figure 2), verifier and extraction research, and reproducing the ProofForge e2e smoke run.

Out of scope: evaluating any prover (these are training-pool statements), and claiming correctness under other Lean or Mathlib versions.

Limitations.

• One model, one round, one temperature. It says nothing about other provers.
• Labels are tied to Lean v4.9.0-rc1 and Mathlib d1d1e4b7. A proof valid here may fail on newer Mathlib.
• The blocklist catches copies and light rewrites, not heavy paraphrases of benchmark problems.
• Completions contain model-written natural-language reasoning, which can be wrong even when the Lean proof is valid.

Risks. Low. The data contains no personal data and is mathematical content only. Training on unfiltered rejected rows as positives would teach wrong proofs, so always join on key and filter on verdict.

9. Reproducibility

# load
python -c "from datasets import load_dataset as L; \
g=L('viai957/proofforge-goedel8b-e2e-attested-generations','generations',split='train'); \
v=L('viai957/proofforge-goedel8b-e2e-attested-generations','verdicts',split='train'); print(len(g),len(v))"

# regenerate (align repo; 4 GPUs). Recorded argv of session 1791951209-4193267, wrapped in hostguard.
# The run passed --model as the local HF snapshot dir of Goedel-LM/Goedel-Prover-V2-8B rev dfd02e62...;
# equivalently use --model Goedel-LM/Goedel-Prover-V2-8B --model-rev dfd02e6271a58375dfbf3ece0175277cf6b6a89a
python scripts/hostguard.py run --cores 16 --mem-gb 60 --label p2-lean-gen -- \
  python extras/vllm_rollout/lean_gen.py \
  --model <HF_HOME>/hub/models--Goedel-LM--Goedel-Prover-V2-8B/snapshots/dfd02e6271a58375dfbf3ece0175277cf6b6a89a \
  --problems .tmp/p2/r1/problems/train_pool.jsonl --out .tmp/p2/r1/pool/gen_r0.jsonl \
  --n 8 --cap-tokens 16384 --round 0 --tp 4 --seed 0 --max-num-seqs 128 --gpu-mem-util 0.82

# e2e proofs/sft/pairs/dpo stages (ProofForge)
python scripts/pf_e2e.py plan   # renders stage configs from configs/e2e/e2e_smoke.yaml + probed HwCaps

artifact	identity
data/gens.attested.jsonl	sha256 1951f443fe7a606c627de4b3b9d3cb4f0588bf59ef8699a0f2463a772459efa4
data/verdicts.pf_strict.jsonl	sha256 d86ce61d72785898942645c5973275af2928a6c4f86d865ccd30bbcdeec9e18f
upstream gen_r0.jsonl / ver_r0.jsonl	sha256 2b4b5f3d... / 5eeb800c... (in viai957/lean-prover-data @ 4058f681, r1/pool/)
source pool	train_pool.jsonl sha256 9e8a9fbc...; e2e pool identity 88e380b1...
attestation code	ProofForge 72e9dfa (proofforge/e2e/attest_shim.py)
SFT mix / DPO mix config	055990de... / 9e845630... (configs/e2e/e2e_smoke.yaml)
e2e SFT / DPO / pairs commits	50453074 / 186238f8 / c5e6c61c
HF archive upload	commit c97a34bd5e43, tool tools/pf_hf_archive.py, scan tools/pf_hf_archive_scan.py

The figures were produced from the files above by _tools/stats.py and _tools/plots.py. Every number in this card is mapped to its source in evidence.json.

10. Related repos, licence, citation

• viai957/proofforge-goedel8b-e2e-smoke-checkpoints: SFT, DPO and RLVR training state from the e2e run that consumed this data.
• viai957/proofforge-goedel8b-sft-lora-e2e-smoke: final e2e SFT adapter.
• viai957/lean-prover-data: source pool and the raw gen_r0 / ver_r0 files.
• viai957/Goedel-Prover-V2-8B-EI-campaign1-r1 (also r2, r3): later expert-iteration models on the same base.
• ProofForge experiment archive collection.

Licence. Apache-2.0 for the generations, which are outputs of the Apache-2.0 Goedel-Prover-V2-8B. The statements come from Goedel-Pset-v1 (no licence declared on its HF card; the Goedel-Prover code repository is MIT), whose informal problems come from NuminaMath (Apache-2.0). Please credit both.

@misc{proofforge_e2e_attested_generations_2026,
  title        = {ProofForge e2e attested generations: verifier-labelled Goedel-Prover-V2-8B samples on Goedel-Pset-v1},
  author       = {viai957},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/viai957/proofforge-goedel8b-e2e-attested-generations}}
}
@article{lin2025goedelproverv2,
  title   = {Goedel-Prover-V2: Scaling Formal Theorem Proving with Scaffolded Data Synthesis and Self-Correction},
  author  = {Lin, Yong and others},
  journal = {arXiv preprint arXiv:2508.03613},
  year    = {2025}
}