# Generator and verifier: technical notes

This directory produces the Harbor tasks in `../tasks/` from a checkout of
[openai/math](https://github.com/openai/math), builds the sandbox image they run in, and contains
the verifier. The dataset card (`../README.md`) covers what the environment is and how to run it;
this file covers how the tasks are generated and graded, the threat model, and the checks behind
the validation.

## Layout

```
openai_math_harbor/
  challenges.py      reads the challenges, maps them to families, applies the hole policy
  import_graph.py    import graph of the openai/math Lean library (reference-proof closures)
  oracle.py          closure and packaging of the reference proofs
  reference.py       places a reference proof as a submission (copied into each task's solution/)
  adapter.py         writes tasks/, registry.json, manifest.parquet, the card and NOTICE
  snapshot.py        builds the shared Daytona snapshot from image/
  report.py          turns a Harbor oracle job into per-task verdicts
  attacks.py         adversarial submissions used to test the verifier
  templates/         instruction, verifier (tests/grade.py, test.sh), oracle (solve.sh), card
image/               Dockerfile and setup scripts for the shared image (= every task's environment/)
tests/               unit tests for the verifier's submission handling
```

## Regenerating the tasks

```bash
# A sparse checkout of openai/math at the pinned commit:
git init openai-math && cd openai-math
git remote add origin https://github.com/openai/math.git
git sparse-checkout set --no-cone /lean/ComparatorChallenges/ /lean/docs/ /overview.tex /LICENSE
git fetch --depth 1 --filter=blob:none origin adc7f1241b42e322a6451854ab7e4b4c146bf78a && git checkout FETCH_HEAD
cd ..

# Optional: the import graph, for reference-proof sizes and the oracle's file lists. Needs the full
# lean/ directory (about 1.8 GB checked out).
python -m openai_math_harbor.import_graph openai-math/lean graph.json

python -m openai_math_harbor.adapter --openai-math openai-math --graph graph.json --out out/
# Stamp oracle verdicts into the tasks after an oracle run:
python -m openai_math_harbor.report <harbor job dir> oracle_results.json
python -m openai_math_harbor.adapter ... --oracle-results oracle_results.json
```

Every challenge goes through the same code; no task is written by hand. Three things are decided
per challenge, all from the data:

| What | Count | Handling |
|---|---|---|
| Definition holes | 9 configs | Comparator checks only the name and type of a `definition_names` entry, never its body, so a solution could redefine `ProperColoring := False` and prove the theorem trivially. A hole whose body is written out is removed from the config, so it must match exactly (8 configs). A hole whose body is `sorry` stays open only if its name appears nowhere else in the file (`ElementaryPositivity`, whose type is the claim). `DefocusingNLS` has a `sorry` inside a definition the theorems use and is excluded. |
| Reference proofs needing other Lean libraries | 23 | PrimeNumberTheoremAnd, StrongPNT, RellichKondrachov and others. Every statement imports only Mathlib, so agents are unaffected; only those official proofs cannot be built in this image. |
| Grading time | all | 3 h plus 15 min per MB of the reference proof, at most 6 h. |

The 137 result families without Lean statements have no machine-checkable target and are not part
of the dataset.

## How a trial runs

```
agent sandbox (snapshot)                    verifier sandbox (same snapshot, fresh)
  /workspace  Lake project, Mathlib           never runs agent code
  agent writes Submission.lean                 /tests: Challenge.lean, task.json, grade.py
  (+ Submission/**.lean)                       /logs/artifacts/submission.tar  <- only input
  no network while the agent runs                1. accept regular Submission*.lean files only
        |                                        2. fresh Lake project, prebuilt read-only Mathlib
  collect hook: pack_submission.py               3. iptables: grader uid gets no sockets
  -> /logs/artifacts/submission.tar ---------->  4. Comparator as `grader`: landrun builds, statement
     (one plain file crosses)                       + axiom check, kernel replay
                                                 5. kill grader processes, delete the build,
                                                    root writes reward.txt
```

Harbor's `[verifier] environment_mode = "separate"` (0.24+) provides the second sandbox. Both
sandboxes start from one Daytona snapshot built from `image/Dockerfile`; every task carries the
identical `environment/`, so the image is built once. Harbor's own Daytona auto-snapshot gives up
after 10 minutes, which is less than the image build takes, hence `snapshot.py`.

## Threat model

| Attempt | What stops it | Test |
|---|---|---|
| `sorry`, `admit`, a tactic macro that expands to `sorry` | `sorryAx` is not a permitted axiom | `sorry`, `sorry-macro` |
| Declare `axiom cheat : False` | only `propext`, `Quot.sound`, `Classical.choice` allowed | `axiom` |
| `implemented_by` + `native_decide` to prove `False` | `native_decide` introduces an axiom of its own | `native-decide-false` |
| Same theorem name, weaker statement | the statement must equal the challenge's exactly | `weaken-statement` |
| Redefine a definition the statement uses | every constant in the statement must match; openai/math's loose hole configs are tightened | `redefine-definition` |
| Keep a structure's name and type but drop a proof obligation from its fields | Comparator also compares the structure's constructor, whose type lists the fields | `tamper-structure` |
| Re-export the trusted Challenge module | its theorems are `sorry` | `import-challenge` |
| Plant `reward.txt` or a fake `comparator` in the agent sandbox | grading runs in a separate fresh sandbox | `agent-side-reward` |
| Lean code run while the verifier builds the proof (`run_cmd`, `#eval`, macros) writes `reward.txt`, runs a shell or opens a connection | landrun (read-only file system except `.lake`, execution limited to Lean and git, TCP denied), unprivileged `grader` user, iptables owner rule; root writes the reward only after killing every grader process | `compile-time-reward` |
| Exhaust the verifier's disk or memory so grading cannot finish | Lake by-products are emptied as the build runs; the build is deleted before the verdict is written, so a full disk still yields reward 0; memory and time are bounded (8 GB, `grade_timeout_sec`) and a killed build scores 0 | `fill-disk` |
| Symlinks, path traversal, device files, hard links, huge archives | the collect hook packs only regular files; `grade.py` accepts only regular `Submission.lean` and `Submission/**.lean` whose path components are Lean identifiers | `symlink`, `tests/test_grade_unpack.py` |
| Read OpenAI's proof | not in the image; the agent phase has no network | network probe (below) |
| A background process in the agent sandbox interfering with grading | Harbor stops the agent sandbox before the verifier starts and empties the verifier's log directory first; on Daytona the two sandboxes share no files | by construction |
| A Lean kernel soundness bug | not covered (Comparator's second kernel, nanoda, is off) | none |
| Memorized public proofs | not covered | none |

Grading fails closed: a rejected or non-compiling submission scores 0. If the trusted side breaks
(the Challenge fails to build, or times out before the submission is reached, or the network block
cannot be installed), no reward is written and Harbor reports the trial as an error rather than 0.

**What each isolation layer was shown to do** on Daytona's kernel (Linux 6.17): under landrun, the
grader's build cannot write outside the build directory and gets `EACCES` on TCP connects. Without
landrun, the grader user *can* reach Daytona's in-sandbox control service on port 2280, so
`grade.py` also installs an iptables rule for that user before Comparator runs and refuses to grade
if the rule does not take effect.

**Trusted, not re-checked here:** the Lean kernel, Comparator's export parser and `lean4export` (a
crafted `.olean` written at build time is only accepted if the kernel replay accepts it), landrun,
and Daytona's sandbox boundary.

## Checks behind the validation

All through `harbor run` on Daytona with the separate verifier; none involves a language model.

| Check | Expected | Result |
|---|---|---|
| Oracle over every task (official proofs) | 1 where the proof fits the image | see the dataset card and each task's `oracle_result` |
| All 405 statements built in one sandbox (`lake build`, 3 threads) | compile | 405 of 405; median 5 s, 90th percentile 7 s, slowest 220 s |
| No-op agent | 0 | 0, "no submission" |
| 12 adversarial submissions (`attacks.py`) | 0 | 0 on all twelve, each rejected for the intended reason (`fill-disk` on Oct 9 with the final grader: "ran out of disk space" after 85 s); the build-time probe printed `write denied`, and neither a shell nor git's HTTP helper could be executed |
| Agent-phase view (oracle agent printing its environment) | no network | DNS fails, HTTPS to github.com times out, a direct-IP connection is refused; `LEAN_NUM_THREADS=3` is set; `/tests` is absent |
| Oracle with `--allow-agent-host github.com` | 1 | 1 (positive control for the network check) |
| landrun and iptables in a Daytona sandbox | both enforce | as described above |

## The image

`image/lean_setup.sh` installs Lean v4.34.1 and Mathlib at the commits openai/math pins, builds
Comparator (`leanprover/comparator@d03acab`) and lean4export with the same toolchain, builds landrun,
copies every challenge statement to `/opt/openai-math/challenges/`, and prepares `/workspace`. Three
details matter:

- **Size.** Lean plus Mathlib is about 11 GB as installed, more than a 10 GB Daytona sandbox. The
  script drops what importing Mathlib never reads: static libraries, LLVM and gcc (needed only to link
  the executables built earlier in the script), and Mathlib's generated C and `.ilean` files,
  truncated with their `.hash` files kept so Lake still treats Mathlib as built. A smoke test fails
  the build if a second `lake build` still compiles any dependency.
- **Threads.** Lean sees every host CPU (64 on Daytona), not the sandbox's 4, so by default Lake
  starts one Mathlib-loaded `lean` per module and runs out of memory. Agents get
  `LEAN_NUM_THREADS=3` (`task.toml`); the verifier uses 2, which reaches Comparator's landrun
  sandbox through a one-line `sed` patch to Comparator's `envPass` lists.
- **Permissions.** Mathlib's cache tool unpacks files as mode 0600. The script makes the toolchain
  and packages world-readable (still root-owned), and a second smoke test builds as the `grader` user.

## Limits

- **Daytona's per-sandbox caps: 4 CPUs, 8 GB memory, 10 GB disk.** The 10 GB is working space on
  top of the image. Lake compiles every module to C as well as to `.olean`; grading never reads the
  C, but for the largest proofs it reached 9.4 GB and filled the disk. `grade.py` therefore empties
  the generated `.c` files every 15 seconds while the build runs (as the `grader` user; Lake keeps
  the recorded hash and does not rebuild), and deletes the build before writing its verdict, so a
  build that still fills the disk scores 0 instead of leaving Harbor waiting for a verifier that
  can no longer report. Some proofs still need more than 8 GB of memory or 6 hours; the oracle
  results record which. Higher per-sandbox limits remove the constraint.
- **The agent sandbox contains Comparator,** since agent and verifier share one image. Nothing in it
  is secret: the statement and the rules are public, and `lake build` plus `#print axioms` already
  tell an agent whether a proof is complete.
- **Difficulty.** These are open research problems; expect a reward of 0 on almost every task.

## Licensing

The statements are redistributed unchanged from openai/math (OpenAI, Apache-2.0); the dataset root
carries `LICENSE-openai-math` and a `NOTICE` describing what was copied, what was adapted (the
Comparator configs) and what is not included (the proofs). The image bundles Lean, Mathlib,
Comparator and lean4export (Apache-2.0) and landrun (MIT). This code is under the Apache License 2.0.