BlackdromeAILabs/lemma-long-horizon-rewrite-benchmark

LEMMA Long-Horizon Symbolic Rewriting Benchmark

Rewrite one expression into another, one verified step at a time — for up to 128 steps.

Every problem gives you a start expression, an exact target, and a reference derivation in which every single step was accepted by a symbolic verifier. The hard part is not any individual rewrite. It is picking the right rewrite at each of up to 128 consecutive states, where a plausible-looking legal move can quietly take you away from the target. One wrong choice loses the problem.

Problems	820 across three difficulty tiers
Depths	2 → 128 rewrite steps
Verified reference steps	18,880
Model	BlackdromeAILabs/lemma-v3-policy
Code	github.com/blackdromeai-labs/LEMMA
License	MPL-2.0

---

Quickstart

from datasets import load_dataset

ds = load_dataset("BlackdromeAILabs/lemma-long-horizon-rewrite-benchmark", "deep")["test"]
print(len(ds))          # 120
print(ds[0]["input"])   # start expression
print(ds[0]["expected"])# target expression

Three tiers are available. deep is the default:

shallow  = load_dataset("BlackdromeAILabs/lemma-long-horizon-rewrite-benchmark", "shallow")["test"]
frontier = load_dataset("BlackdromeAILabs/lemma-long-horizon-rewrite-benchmark", "frontier")["test"]
deep     = load_dataset("BlackdromeAILabs/lemma-long-horizon-rewrite-benchmark", "deep")["test"]

What one problem looks like

{
  "id": "id-collect-d2-001",
  "family": "collect-after-noise",
  "split": "ID",
  "partition": "locked-test",
  "construction_depth": 2,
  "generator_seed": 5495883914480123905,
  "input": "1 * (3 * x + 6 * x)",
  "expected": "9 * x",
  "reference_rules": ["algebra::identity_mul_one", "algebra::collect_like_terms"]
}

Read it as: strip the 1 *, then collect 3x + 6x into 9x. That is a depth-2 problem from the easiest tier. A depth-128 problem in the deep tier is the same idea with 128 such decisions stacked, most of them offering a tempting wrong move.

reference_rules is one derivation that provably works. It is not claimed to be the shortest, and a solver is free to find a different valid route.

---

The three tiers

Config	Problems	Depths	Verified steps	Unguided search solves	Role
shallow	400	2, 3, 4, 6, 8	1,840	400 / 400	saturated — regression corpus
frontier	300	8, 12, 16, 24, 32	5,520	145 / 300	where search starts failing
deep (default)	120	64, 96, 128	11,520	31 / 120	the paper's evaluation tier

Unguided (uniform-prior) search is saturated at depths 2–8, collapses between depth 12 and 16, and by depth 64+ solves only a forced single-path family. That progression is the whole reason a learned policy is worth training: the deep tier is the only one where guidance has room to matter.

Scope of the paper's claims

The paper evaluates on the 120-problem deep tier, and its headline metric is the 89-problem meaningful subset of that tier. No claim in the paper covers all 820 problems. shallow and frontier are supplementary difficulty calibration: separately frozen and validated, carrying uniform-search baselines only. No trained-model result exists for them, and no paper table depends on them.

Caveat on the table above: budgets differ (150 simulations for shallow, 400 for the other two). It is a ladder of difficulty, not a controlled budget comparison. shallow is already at 100%, so more budget cannot change it.

---

Why 89 and not 120

Branching was measured directly at every state of every reference path, counting successors exactly the way the search does — guardrail admission, applicability, must-change-state, and verifier acceptance:

Split	Wrapper family	Problems	States	Mean branching	Decision points
deep-ID	identity	60	5,760	1.49	2,832 (49%)
deep-OOD	double_negative	31	2,848	1.00	12 (0.4%)
deep-OOD	power_of_one	29	2,912	1.98	2,854 (98%)

The 31 double_negative problems are a forced corridor: there is essentially one legal move at every state, so anything that can walk forward solves them for free. Averaging them in inflates every score.

So the headline metric is the 89-problem subset (identity + power_of_one), with the 120-problem total reported next to it. Wrapper family is not a stored column — derive it from reference_rules the way the evaluator does:

def wrapper_family(row):
    has_pow = any("power_of_one" in k for k in row["reference_rules"])
    has_neg = any("double_negative" in k for k in row["reference_rules"])
    if has_pow and not has_neg: return "power_of_one"
    if has_neg and not has_pow: return "double_negative"
    return "mixed" if has_pow else "identity"

meaningful = [r for r in deep if wrapper_family(r) != "double_negative"]  # 89 problems

---

Schema

deep and shallow share a schema:

Column	Type	Description
id	string	Stable identifier, e.g. deep-OOD-d64-001
family	string	Generator family, e.g. deep-ID-fold
split	string	deep-ID / deep-OOD, or ID / OOD in shallow
partition	string	Always locked-test
construction_depth	int32	Length of the reference derivation
generator_seed	int64	Frozen seed, identical across a tier
input	string	Start expression
expected	string	Exact target expression
reference_rules	list[string]	Ordered rule keys of the verified derivation

frontier comes from a different generator: it has no partition or generator_seed, uses track (wrapped-ID / wrapped-OOD) instead of split, and adds source_id naming the base problem it was extended from. Load tiers explicitly rather than assuming one schema.

Expressions use LEMMA's surface syntax: * and + explicit, ^ for powers, no implicit multiplication. 1 * (3 * x + 6 * x), not 1(3x + 6x).

---

Reproducing the paper

All numbers below come from the shipped result JSONs. Recompute every one of them with no model, no GPU and no network:

python scripts/verify_release.py

Headline: six decision procedures, deep tier, 400-successor budget

Same frozen v3 checkpoint wherever a model is involved; identity out of 60, power_of_one out of 29.

Decision procedure	Total (/120)	identity	power_of_one	Meaningful (/89)
Uniform MCTS	31	0	0	0
Value-only MCTS	31	0	0	0
Beam search (width 8)	31	0	0	0
Policy–value MCTS	92	44	17	61
Policy-only MCTS	118	60	27	87
Greedy learned policy	120	60	29	89

Beam search is budget-limited, not incapable: at a 1600-successor cap it reaches 89/89. Budget sweep for policy–value MCTS on the 89 subset: 0 at 50 sims, 22 at 100, 53 at 200, 61 at 400, 65 at 800.

Which file backs which table

Paper table	Files in results/
Headline six-way comparison	results_uniform_families.json, results_v3_value_only.json, results_v3_beam8_sims400.json, results_v3_policy_value.json, results_v3_policy_only.json, results_v3_greedy.json
Beam budget curve	results_v3_beam8_sims{400,800,1600}.json
Depth breakdown, v1/v2/v3 lineage	results_6arm_measured.json
Goal-conditioning ablation	results_ablation_{with,no}_goal_seed{1,2,3}.json
Simulation-budget sweep	results_v3_sims{50,100,200,400,800}.json
Value-head calibration	value_head_diagnostics.json

results/supplementary/ holds the two uniform baselines behind the difficulty-ladder table. No paper table uses them. shallow_trained_vs_uniform_sims150.json also records an earlier trained arm (272/400) that is not the paper's v3 checkpoint; the tier is saturated, so that number measures nothing about guidance and is kept only for completeness.

Running a solver yourself

git clone https://github.com/blackdromeai-labs/LEMMA && cd LEMMA
cargo run --release -p mm-solver --example deep_eval -- run corpus.jsonl 400 <arm>

Arm names for the six headline rows, in order: uniform, v3_value_only, v3_beam8, v3_policy_value, v3_policy_only, v3_greedy.

---

Files, validation and integrity

Path	What it is
data/*.parquet	What load_dataset reads — derived from the JSONL
data/*.jsonl	Canonical. What the recorded hashes and the paper refer to
results/	Result JSONs behind every paper table
results/supplementary/	Uniform baselines for the two supplementary tiers
docs/	Original provenance records for the supplementary tiers
scripts/verify_release.py	Recomputes every published number
scripts/build_parquet.py	Regenerates the Parquet copies, with a round-trip check
SHA256SUMS	Hash of every file

The JSONL files are canonical; Parquet is a derived convenience so the viewer renders and columns arrive typed. build_parquet.py verifies every value survives the round trip.

Each tier ships a fail-closed validator that rejects duplicate ids, duplicate (input, expected) pairs, depth mismatches, foreign seeds, expressions that do not round-trip through parse and format, unknown or inapplicable rule keys, any rule with other than exactly one verifier-accepted application at its state, and any replay that misses its target.

sha256sum -c SHA256SUMS

cargo run --release -p mm-solver --example deep_eval -- validate data/corpus.jsonl
# validated 120 problems, 11520 reference steps, branching min/mean/max = 1/1.54/2

cargo run --release -p mm-solver --example neurosymbolic_benchmark -- validate data/shallow_corpus.jsonl
# validated 400 problems, 1840 reference steps, branching min/mean/max = 1/1.34/3

cargo run --release -p mm-solver --example frontier_search_benchmark -- validate data/frontier_corpus.jsonl
# validated 300 problems; branching 1/1.46/3

Line endings. The shallow and frontier sources are tracked in a repository checked out with core.autocrlf=true, so a Windows working copy carries CRLF while the canonical content is LF. They are published LF-normalized, which is why data/frontier_corpus.jsonl hashes to bdb0e0cc…c97e0e4e, exactly the value recorded in docs/frontier_SUITE.md. The deep corpus was already LF and is byte-identical to its source.

---

How the problems are built

Each problem wraps a small solvable core in layers that must be peeled off in order.

1. A core rewrite is drawn from four families: collect_like_terms, const_fold, distribute, zero_mul.
2. Wrapper layers are added until the reference path reaches the target depth. deep-ID wraps in identity-collision layers (identity_mul_one, identity_add_zero); deep-OOD repeats one motif per problem, either power_of_one or double_negative.
3. The construction is replayed against the live rule engine and verifier. Anything that does not land exactly on its stated target is discarded, never relabeled.

Generation is deterministic from one frozen seed per tier. Exact-input collisions with training corpora are excluded before freezing. Eight distinct rules appear across the deep tier's reference paths: algebra::collect_like_terms, const_fold, distribute, double_negative, identity_add_zero, identity_mul_one, power_of_one, zero_mul.

deep-OOD is a legacy split name. Its motifs were out-of-distribution for the v1 model but are present in the v2/v3 curriculum, so results there measure held-out instances, not structural out-of-distribution transfer. Do not read the name as an OOD claim.

---

Intended use

• Measuring whether a policy sustains correct action selection over long dependent chains.
• Comparing decision procedures (MCTS, beam, greedy) against a fixed, verifier-admitted successor function, holding the successor set constant.
• Studying goal conditioning and value-head calibration in symbolic rewriting.

Limitations

• Internally constructed. Problems come from LEMMA's own rule templates, not from humans or an external mathematics dataset. Nothing here transfers to natural-language math benchmarks, and it must not be reported as if it did.
• Narrow vocabulary. Eight rules appear in the deep tier's reference paths, out of 572 registered. This benchmark exercises depth and branching, not mathematical breadth.
• The 31 double_negative problems are free. Always report the 89-problem subset alongside any 120-problem total.
• Depth is construction depth, not a proven shortest path.
• One frozen seed per tier — a single deterministic sample, not a distribution over corpora.
• Supplementary tiers carry no trained-arm results. The v3 checkpoint was never run on them.
• Solve rates are single deterministic runs. Reruns reproduce exactly; that is reproducibility, not a variance estimate.

Citation

@article{saxena2026lemma,
  title   = {LEMMA: Learned Guidance for Evidence-Carrying Long-Horizon Symbolic Rewriting},
  author  = {Saxena, Atul and Kharat, Pushp},
  year    = {2026},
  note    = {BlackdromeAI Labs and Pkboost AI Labs},
  url     = {https://github.com/blackdromeai-labs/LEMMA}
}

License

Mozilla Public License 2.0, matching the generating code. All content is generated by LEMMA's own code; no third-party or imported mathematical dataset is included or redistributed here.