Ingot-Lean-Zig: Lean 4 theorems as tested Zig 0.17

A sibling of ego0op/ingot-zig. Each row takes one fact proved in a Lean 4 library (integer arithmetic, bit-vectors, hash maps, balanced trees, number theory, finite fields, NTT, RISC-V and ARM64 instruction semantics). It is written as a Zig 0.17 function that computes the result and asserts the theorem in its own body, plus a test block that checks 16 known outputs. Every shipped file passed zig test on Zig 0.17.0 exactly as it appears here.

from datasets import load_dataset
ds = load_dataset("ego0op/ingot-lean-zig", split="train")   # 1,828 standalone Zig files

Configs

config	rows	what it is	use it for
train	1,828	the true units: function + asserted theorem + 16-vector test	training, fine-tuning
workbook	1,208	proved Lean-Workbook competition statements over ℕ/ℤ, translated by the rule-based lean2zig converter: the Lean statement as a /// comment, each side as a Zig function, and a test checking the statement on generated inputs	training, Lean↔Zig translation pairs
twin	1,828	an operator-matched "twin" of each unit: same operators, different wiring, so its assert is false on at least one vector (diverges_on)	contrastive and null-control experiments. Not for plain training

About 4.6 MB, ≈1.4M tokens with the test blocks (≈0.66M for the function bodies alone). Token counts are estimated as in Ingot (3.27 bytes per token).

How each unit was checked

In order, from 4,445 generated candidates (every stage's drop count is in stats.json and the build ledger):

1. Generation. Each unit comes from a cited Lean declaration (source_repo, source_commit, source_file, lean_decl). Degenerate filler arithmetic such as x *% 1 is folded away, and the theorem is stated as std.debug.assert(lhs == rhs) in the body.
2. Structure. Exact and near duplicates are removed. Near duplicates are measured on identifier- and literal-normalised 5-grams, and each family is calibrated to a near-duplicate rate of at most 25%. Real Zig sits at 9–12%, so v3.1 doesn't push it to zero.
3. Run. 16 vectors with edge values (0, 1, max, max−1, min, powers of two) under Debug and ReleaseSafe. The theorem must hold on every vector and be actively exercised by at least one. 480 generated "theorems" failed at type edges and were dropped.
4. Targets. Compiles for x86_64-linux, aarch64-linux and wasm32-freestanding.
5. Decontamination. No 13-gram overlap with Ingot-Bench, the Ingot held-out files, or the Babel evaluation sets.
6. Repackage. The standalone file shipped here (std import + function + test) was re-run with zig test: 1,828/1,828 pass.

workbook: Lean statements converted by rule

internlm/Lean-Workbook (Apache-2.0) holds competition-math statements formalised in Lean 4, many with machine-checked proofs. lean2zig translates the integer ones by rule, not with a language model.

• Exact Lean semantics live in zig/lean.zig: ℕ subtraction stops at 0, x / 0 = 0, x % 0 = x, and ℤ division and modulo are Euclidean. All arithmetic is in overflow-checked i128.
• Verified by running. The statement is proved, so it must hold on every generated input that meets its hypotheses. A disagreement means a translation bug, and the row is dropped. The final run had 0 disagreements. The 6 found during development were translator bugs and are fixed. The helpers separately pass 3,266 cases against a reference implementation of Lean's integer rules.
• Funnel. 10,434 unique proved statements, 2,268 inside the supported fragment (60% are about real numbers and can't run as integer code), 1,900 that pass, 1,208 kept. Dropped along the way: 629 constants such as 2 % 2 = 0, 12 tautologies, and 51 to hold the near-duplicate rate at ≤25%.
• Usage. Each file imports lean.zig. Put zig/lean.zig next to it to compile or test.

Mix

family	rows		family	rows
LeanCore.KernelContextual	910		Mathlib.CombinatoricsIndex	67
Mathlib.LinearAlgebraPoly	134		Batteries.HeapsRBMapFin	62
LeanCore.BitVec	131		LeanCore.StdDTreeMap	60
ZkEvm.PrimeFields	97		LNSym.Arm64Isa	50
Mathlib.NumberTheory	82		LeanCore.NatIntDivGcd	40
LeanCore.StdHashMapArray	77		ZkEvm.NTT	40
ZkEvm.RiscvIsa	74		Batteries.UnionFind	4

KernelContextual is half the rows, about 29% of tokens. If you evaluate on this data, report results per family.

Limits

• These are generated programs, not human-written code. Each one encodes a real Lean theorem, but the code shape is the generator's. Expect a narrower style than ingot-zig and mix it in alongside real Zig, not instead of it.
• Two families stay repetitive, by design. A minimum of 40 units per family keeps NTT (95% near-duplicate rate) and NatIntDivGcd (70%) templated. UnionFind is down to 4 units: 59 of its 63 verified units overlap the evaluation benchmarks (13-gram check) and were removed to keep those benchmarks clean. More UnionFind needs new source material, not a looser filter.
• workbook is arithmetic, not algorithms. It holds identities and divisibility facts about integers, which is narrower than the train families.
• 16 vectors is testing, not proof. The Lean proof covers all inputs; the Zig check covers the vectors.
• The functions use wrapping arithmetic (+%, *%) where the Lean statement is about fixed-width words.

License

Each row carries the license of the Lean library it was derived from (license, license_text): Apache-2.0 (lean4, batteries, mathlib4, LNSym, ArkLib, CompPoly) or BSD-2-Clause (riscv-zkvm RiscvZkvm/Isa). workbook rows are derived from internlm/Lean-Workbook (Apache-2.0). See LICENSE.md. The collection layout and the build tools are MIT.

Built by Opus · Smelter (Claude) with Gokce Özdemir as part of the Babel project, from Argon · Arbiter's Lean→Zig generators.