Zayden-Jung
d3555d9a52
Replaces the previous tree entirely. The pipeline is four separable pieces, each
testable on its own:
1. leanbench/llm.py provider-neutral OpenAI-compatible connector, stdlib only,
with retries, JSON coercion and a scripted client so the
rest of the code is testable without a network.
2. leanbench/detect.py per-page detection of formalizable mathematics. Case 1 is
mathematics asserted as fact (definition/theorem/lemma/...,
deliberately not sub-classified); case 2 is a problem left
open to the reader. Hits come back as spans -- start page
and index, end page and index -- so several per page is
normal. A hit cut off by the page end makes the detector
re-read that page together with the next, repeatedly, so an
item spread over three pages is found whole.
Offsets come from verbatim quotes resolved by
leanbench/anchors.py (exact -> whitespace-insensitive ->
fuzzy), because models quote well and count badly.
3. leanbench/formalize.py + leanbench/verify.py
each span becomes one Lean 4 declaration, judged by the real
compiler: full elaboration for case 1, statement legality
only for case 2, which has no proof to check. Lean's own
diagnostics feed back for a repair attempt. "verified" (Lean
accepted it) and "proved" (accepted with no sorry) are kept
strictly apart.
4. leanbench/db.py indexed SQLite plus JSONL export. Every item is indexed by
the types of its inputs, or by its own type when it is not a
proof, and records the source book (sha256) and the page it
starts on -- so `drop --source H --pages A-B` followed by a
re-ingest redoes exactly those pages and nothing else.
Also: lean/ Lake project pinned to Mathlib, docker/ image carrying Lean 4 and a
prebuilt Mathlib (the Mathlib revision and the toolchain are resolved against each
other at build time rather than both hardcoded), and .gitea/workflows for tests,
image build and push to the Gitea registry, and a manual "submit a book" run.
58 tests; they need neither network nor Lean.
39 lines
1.1 KiB
Python
39 lines
1.1 KiB
Python
from __future__ import annotations
|
|
|
|
import pytest
|
|
|
|
from leanbench.llm import LLMError, ScriptedClient, extract_code, parse_json
|
|
|
|
|
|
def test_parse_json_plain() -> None:
|
|
assert parse_json('{"a": 1}') == {"a": 1}
|
|
|
|
|
|
def test_parse_json_through_a_fence() -> None:
|
|
assert parse_json('```json\n{"a": [1, 2]}\n```') == {"a": [1, 2]}
|
|
|
|
|
|
def test_parse_json_with_chatter_around_it() -> None:
|
|
assert parse_json('Sure!\n{"ok": true}\nHope that helps.') == {"ok": True}
|
|
|
|
|
|
def test_parse_json_raises_when_there_is_none() -> None:
|
|
with pytest.raises(ValueError):
|
|
parse_json("no json here")
|
|
|
|
|
|
def test_extract_code_pulls_the_lean_block() -> None:
|
|
raw = "Here you go:\n```lean4\ntheorem t : True := trivial\n```\nDone."
|
|
assert extract_code(raw) == "theorem t : True := trivial"
|
|
|
|
|
|
def test_extract_code_passes_bare_code_through() -> None:
|
|
assert extract_code("theorem t : True := trivial") == "theorem t : True := trivial"
|
|
|
|
|
|
def test_scripted_client_runs_out_loudly() -> None:
|
|
client = ScriptedClient(["one"])
|
|
assert client.complete([]) == "one"
|
|
with pytest.raises(LLMError):
|
|
client.complete([])
|