369 validated tasks; grader keeps large builds within the 10 GB disk (part 11)

Re-ran the oracle with the updated verifier. The verifier now empties Lake's per-module setup files and generated C once each module is built, and deletes the build before writing its verdict, so a build that fills the disk scores 0 instead of leaving the trial without a result. 14 more tasks validated; not-validated list updated.

tasks/infinite-matroid-corollaries/task.toml

@@ -23,7 +23,7 @@ reference_modules = 33
 reference_lean_bytes = 193312
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 637
+oracle_grade_seconds = 155
 difficulty = "research"
 
 [agent]

tasks/infinite-matroid-corollaries/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/interpolated-factors/task.toml

@@ -23,7 +23,7 @@ reference_modules = 77
 reference_lean_bytes = 1249281
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1971
+oracle_grade_seconds = 1361
 difficulty = "research"
 
 [agent]

tasks/interpolated-factors/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/invariant-ising/environment/Dockerfile

@@ -0,0 +1,8 @@
+# Shared by every openai/math task (agent and separate verifier). See lean_setup.sh.
+FROM ubuntu:24.04
+ENV ELAN_HOME=/opt/elan \
+    PATH=/opt/elan/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
+    LANG=C.UTF-8
+COPY lean_setup.sh fetch_mathlib.sh lakefile.lean lake-manifest.json pack_submission.py /opt/build/
+RUN bash /opt/build/lean_setup.sh
+WORKDIR /workspace

tasks/invariant-ising/environment/fetch_mathlib.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Unpack Mathlib's prebuilt cache in batches and truncate the files that importing Mathlib never
+# reads (generated C and .ilean editor indexes), keeping their .hash files so Lake still sees every
+# module as built. Lean + full Mathlib otherwise needs ~11 GB, more than a 10 GB sandbox disk.
+set -euo pipefail
+cd /opt/lean-env
+trim() {
+  find .lake/packages -path '*/.lake/build/*' \( -name '*.c' -o -name '*.ilean' \) -size +0 -exec truncate -s 0 {} +
+  rm -rf "${HOME:-/root}/.cache/mathlib"
+}
+for dir in .lake/packages/mathlib/Mathlib/*/; do
+  name=$(basename "$dir")
+  echo "== Mathlib/$name"
+  lake exe cache get ".lake/packages/mathlib/Mathlib/$name" >/dev/null
+  trim
+  df -h / | tail -1
+done
+lake exe cache get
+trim

tasks/invariant-ising/environment/lake-manifest.json

@@ -0,0 +1,116 @@
+{
+ "version": "1.2.0",
+ "packagesDir": ".lake/packages",
+ "packages": [
+  {
+   "url": "https://github.com/leanprover-community/mathlib4.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612",
+   "name": "mathlib",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612",
+   "inherited": false,
+   "configFile": "lakefile.lean"
+  },
+  {
+   "url": "https://github.com/leanprover-community/plausible",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c",
+   "name": "plausible",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"
+  },
+  {
+   "url": "https://github.com/leanprover-community/LeanSearchClient",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707",
+   "name": "LeanSearchClient",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"
+  },
+  {
+   "url": "https://github.com/leanprover-community/import-graph",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "e928b72544873815af278d38681b31c0293588e3",
+   "name": "importGraph",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"
+  },
+  {
+   "url": "https://github.com/leanprover-community/ProofWidgets4",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5",
+   "name": "proofwidgets",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"
+  },
+  {
+   "url": "https://github.com/leanprover-community/aesop",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "355695d523e41d0554926416cba2a2b3544fbbc9",
+   "name": "aesop",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.toml"
+  },
+  {
+   "url": "https://github.com/leanprover-community/quote4",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259",
+   "name": "Qq",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.toml"
+  },
+  {
+   "url": "https://github.com/leanprover-community/batteries",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2",
+   "name": "batteries",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"
+  },
+  {
+   "url": "https://github.com/leanprover/lean4-cli",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover",
+   "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204",
+   "name": "Cli",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v4.34.0",
+   "inherited": true,
+   "configFile": "lakefile.toml"
+  }
+ ],
+ "name": "openai_math",
+ "lakeDir": ".lake"
+}

tasks/invariant-ising/environment/lakefile.lean

@@ -0,0 +1,12 @@
+import Lake
+open Lake DSL
+
+-- Mathlib at the commit openai/math pins. Agents write `Submission.lean` and `Submission/**.lean`.
+package openai_math where
+  leanOptions := #[⟨`autoImplicit, false⟩]
+
+require mathlib from git
+  "https://github.com/leanprover-community/mathlib4.git" @ "d13f23b723b8a846827a245b89c10fc7d3f11612"
+
+-- `Submission` and every `Submission.*` module it imports.
+lean_lib Submission

tasks/invariant-ising/environment/lean_setup.sh

@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# Builds the image shared by every openai/math task, for both the agent and the separate verifier:
+#   - Lean v4.34.1 and Mathlib d13f23b, the versions openai/math pins (Mathlib only, no OAI library)
+#   - Comparator, lean4export and landrun, used only by the verifier's grade.py
+#   - every challenge statement, at /opt/openai-math/challenges/<Name>.lean
+#   - /workspace, a Lake project where the agent writes Submission.lean
+# All revisions are pinned. The openai/math library (the reference proofs) is never installed.
+set -euxo pipefail
+export DEBIAN_FRONTEND=noninteractive
+
+LEAN_TOOLCHAIN=leanprover/lean4:v4.34.1
+OPENAI_MATH_REV=adc7f1241b42e322a6451854ab7e4b4c146bf78a
+COMPARATOR_REV=d03acab154d269c06e60e4de7e4cc85deebff94b   # "bump toolchain to v4.34.0"; built with v4.34.1
+LANDRUN_REV=811cfff51ceaf3d9843708aa6d22e9b84ccac8b4
+GO_VERSION=1.24.7
+
+apt-get update -qq
+apt-get install -y -qq --no-install-recommends git curl ca-certificates build-essential xz-utils \
+  zstd python3 procps iproute2 iptables tmux >/dev/null
+rm -rf /var/lib/apt/lists/*
+git config --system --add safe.directory '*'
+
+export ELAN_HOME=/opt/elan PATH=/opt/elan/bin:$PATH
+curl -sSfL https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh \
+  | sh -s -- -y --default-toolchain "$LEAN_TOOLCHAIN" --no-modify-path
+
+# --- Verifier tools, built before Mathlib so the build trees are gone before the big download ---
+curl -sSfL "https://go.dev/dl/go${GO_VERSION}.linux-amd64.tar.gz" | tar -C /tmp -xz
+GOBIN=/usr/local/bin GOPATH=/tmp/gopath GOCACHE=/tmp/gocache \
+  /tmp/go/bin/go install "github.com/zouuup/landrun/cmd/landrun@${LANDRUN_REV}"
+rm -rf /tmp/go /tmp/gopath /tmp/gocache
+
+git clone -q https://github.com/leanprover/comparator.git /tmp/comparator
+(
+  cd /tmp/comparator
+  git checkout -q "$COMPARATOR_REV"
+  # Comparator passes only PATH/HOME/LEAN_ABORT_ON_PANIC into its landrun sandbox. Also pass
+  # LEAN_NUM_THREADS: Lean sees every host CPU (64) rather than the sandbox's 4, so without it Lake
+  # starts one Mathlib-loaded `lean` per module and an 8 GB sandbox runs out of memory. It bounds
+  # parallelism only and does not affect what is checked.
+  sed -i 's/envPass := #\["PATH", "HOME", "LEAN_ABORT_ON_PANIC"\]/envPass := #["PATH", "HOME", "LEAN_ABORT_ON_PANIC", "LEAN_NUM_THREADS"]/; s/envPass := #\["PATH", "HOME", "LEAN_PATH", "LEAN_ABORT_ON_PANIC"\]/envPass := #["PATH", "HOME", "LEAN_PATH", "LEAN_ABORT_ON_PANIC", "LEAN_NUM_THREADS"]/' Main.lean
+  test "$(grep -c '"LEAN_NUM_THREADS"' Main.lean)" -eq 2
+  echo "$LEAN_TOOLCHAIN" > lean-toolchain
+  lake build lean4export comparator
+  install -m 0755 .lake/build/bin/comparator /usr/local/bin/comparator
+  install -m 0755 .lake/packages/lean4export/.lake/build/bin/lean4export /usr/local/bin/lean4export
+)
+rm -rf /tmp/comparator
+
+# --- Lean project with Mathlib ---
+# Packages are shallow clones at the manifest revisions, so Lake sees the right HEAD and never fetches.
+mkdir -p /opt/lean-env/.lake/packages
+cd /opt/lean-env
+echo "$LEAN_TOOLCHAIN" > lean-toolchain
+cp /opt/build/lakefile.lean /opt/build/lake-manifest.json .
+python3 - <<'PY'
+import json, subprocess
+for p in json.load(open("lake-manifest.json"))["packages"]:
+    d = f".lake/packages/{p['name']}"
+    subprocess.run(["git", "init", "-q", d], check=True)
+    subprocess.run(["git", "-C", d, "remote", "add", "origin", p["url"]], check=True)
+    subprocess.run(["git", "-C", d, "fetch", "-q", "--depth", "1", "origin", p["rev"]], check=True)
+    subprocess.run(["git", "-C", d, "checkout", "-q", "FETCH_HEAD"], check=True)
+PY
+# Linking native executables (Comparator above, Mathlib's cache tool here) is the only use of the
+# static libraries, LLVM and gcc; `lean` and `lake build` of a library need none of them. Dropping
+# them before the Mathlib download keeps the build, and the image, under Daytona's 10 GB disk.
+lake exe cache --help >/dev/null 2>&1 || true
+find /opt/elan/toolchains/*/lib -name '*.a' -delete
+rm -f /opt/elan/toolchains/*/lib/libLLVM* /opt/elan/toolchains/*/lib/libclang-cpp*
+apt-get purge -y -qq $(dpkg-query -W -f '${binary:Package}\n' build-essential 'gcc-13*' 'g++-13*' \
+  'cpp-13*' 'libstdc++-13-dev*' 'libgcc-13-dev*' 2>/dev/null) >/dev/null || true
+apt-get autoremove -y -qq >/dev/null || true
+bash /opt/build/fetch_mathlib.sh
+rm -f /opt/lean-env/.lake/packages/mathlib/.lake/build/bin/cache
+
+# --- Challenge statements (public; the reference proofs are not fetched) ---
+git init -q /tmp/oai && cd /tmp/oai
+git remote add origin https://github.com/openai/math.git
+git config core.sparseCheckout true
+echo "lean/ComparatorChallenges/" > .git/info/sparse-checkout
+git fetch -q --depth 1 --filter=blob:none origin "$OPENAI_MATH_REV"
+git checkout -q FETCH_HEAD
+mkdir -p /opt/openai-math/challenges
+cp lean/ComparatorChallenges/*.lean /opt/openai-math/challenges/
+cd / && rm -rf /tmp/oai
+install -m 0755 /opt/build/pack_submission.py /opt/openai-math/pack_submission.py
+
+# --- Agent workspace and the verifier's unprivileged user ---
+mkdir -p /workspace/.lake
+cp /opt/lean-env/lakefile.lean /opt/lean-env/lake-manifest.json /opt/lean-env/lean-toolchain /workspace/
+ln -s /opt/lean-env/.lake/packages /workspace/.lake/packages
+useradd --uid 2000 --create-home --shell /usr/sbin/nologin grader
+mkdir -p /var/lib/oai-grade && chmod 0711 /var/lib/oai-grade
+
+# Smoke test. The first build may rebuild a few dependency modules the cache lacks (they persist in
+# the image); a second build must compile nothing but Submission, or agents would pay for it.
+cd /workspace
+printf 'import Mathlib\n\nexample : (2 : ℕ) + 2 = 4 := by norm_num\n' > Submission.lean
+lake build Submission 2>&1 | grep -E 'Built|error' | grep -v 'Built Submission' | head -20 || true
+echo '-- second build' >> Submission.lean
+lake build Submission 2>&1 | tee /tmp/smoke.log
+if grep 'Built' /tmp/smoke.log | grep -qv 'Built Submission'; then
+  echo "the prebuilt Mathlib is incomplete: a second build still compiled dependencies" >&2; exit 1
+fi
+rm -rf Submission.lean .lake/build /tmp/smoke.log
+
+# Mathlib's cache tool unpacks files as 0600. The verifier builds as the unprivileged `grader` user,
+# so everything must be world-readable (and stays root-owned, so not writable).
+chmod -R a+rX /opt/elan /opt/lean-env /opt/openai-math
+# Same smoke test as `grader`, in a scratch project like the one grade.py lays out.
+smoke=$(mktemp -d /var/lib/oai-grade/smoke.XXXX)
+cp /opt/lean-env/lakefile.lean /opt/lean-env/lake-manifest.json /opt/lean-env/lean-toolchain "$smoke/"
+mkdir "$smoke/.lake" && ln -s /opt/lean-env/.lake/packages "$smoke/.lake/packages"
+printf 'import Mathlib\n\nexample : (2 : ℕ) + 2 = 4 := by norm_num\n' > "$smoke/Submission.lean"
+chmod 0755 "$smoke" && chown grader "$smoke/.lake"
+(cd "$smoke" && runuser -u grader -- env -i PATH="$(echo /opt/elan/toolchains/*/bin):/usr/bin:/bin" HOME="$smoke" \
+  lake build Submission) 2>&1 | tee /tmp/smoke.log
+if grep 'Built' /tmp/smoke.log | grep -qv 'Built Submission' || ! grep -q 'Build completed successfully' /tmp/smoke.log; then
+  echo "the grader user cannot build against the prebuilt Mathlib" >&2; exit 1
+fi
+rm -rf "$smoke" /tmp/smoke.log
+
+rm -rf /opt/build /root/.cache
+df -h / | tail -1
+du -sh /opt/elan /opt/lean-env

tasks/invariant-ising/environment/pack_submission.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Pack the agent's proof into one file for the verifier.
+
+Harbor runs this as a [[verifier.collect]] hook in the agent's sandbox after the agent finishes.
+It clears /logs/artifacts and writes /logs/artifacts/submission.tar holding only regular
+`Submission.lean` and `Submission/**.lean` files. Symlinks and other entries are skipped, never
+followed, so only one plain file crosses to the verifier sandbox.
+
+The agent's sandbox is untrusted, so the verifier re-checks every entry of the archive. This step
+only keeps the transfer small and free of links.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import stat
+import tarfile
+from pathlib import Path
+
+WORKSPACE = Path("/workspace")
+OUT_DIR = Path("/logs/artifacts")
+MAX_TOTAL_BYTES = 768 << 20
+
+
+def clear(directory: Path) -> None:
+    directory.mkdir(parents=True, exist_ok=True)
+    for entry in directory.iterdir():
+        if entry.is_dir() and not entry.is_symlink():
+            shutil.rmtree(entry)
+        else:
+            entry.unlink()
+
+
+def regular(path: Path) -> bool:
+    try:
+        return stat.S_ISREG(path.lstat().st_mode)
+    except OSError:
+        return False
+
+
+def main() -> None:
+    clear(OUT_DIR)
+    tmp = OUT_DIR / "submission.tar.part"
+    total = 0
+    with tarfile.open(tmp, "w", format=tarfile.PAX_FORMAT) as tar:
+        root = WORKSPACE / "Submission.lean"
+        if regular(root):
+            total += root.lstat().st_size
+            if total > MAX_TOTAL_BYTES:
+                raise SystemExit("submission exceeds the size limit")
+            tar.add(root, arcname="Submission.lean", recursive=False)
+        tree = WORKSPACE / "Submission"
+        if tree.is_dir() and not tree.is_symlink():
+            for dirpath, dirnames, filenames in os.walk(tree, followlinks=False):
+                dirnames[:] = [d for d in dirnames if not (Path(dirpath) / d).is_symlink()]
+                for name in sorted(filenames):
+                    path = Path(dirpath) / name
+                    if not name.endswith(".lean") or not regular(path):
+                        continue
+                    total += path.lstat().st_size
+                    if total > MAX_TOTAL_BYTES:
+                        raise SystemExit("submission exceeds the size limit")
+                    tar.add(path, arcname=str(path.relative_to(WORKSPACE)), recursive=False)
+    tmp.rename(OUT_DIR / "submission.tar")
+    print(f"packed {total} bytes")
+
+
+if __name__ == "__main__":
+    main()

tasks/invariant-ising/instruction.md

@@ -0,0 +1,546 @@
+# openai/math challenge `InvariantIsing` (family 234)
+
+Prove the following result from OpenAI's [openai/math](https://github.com/openai/math) release in
+Lean 4, with a proof the Lean kernel accepts.
+
+Context: this statement belongs to family 234 of the release, *All-temperature pressure for orthogonally invariant Ising spin glasses*
+(Probability and statistical mechanics). The family as a whole: Gives an exact variational formula for the limiting pressure of orthogonally invariant Ising spin glasses at every fixed temperature, both almost surely and in expectation. The coupling matrix is a Haar-random rotation of a deterministic spectrum converging to a compactly supported law, with extreme eigenvalues converging to its support edges. The zero-field ground-state energy follows as temperature tends to zero.
+
+The challenge is `InvariantIsing`, also at `/opt/openai-math/challenges/InvariantIsing.lean`:
+
+```lean
+import Mathlib
+
+namespace OAI
+
+/-! All-temperature invariant Ising pressure and its magnetic, random-spectral,
+ground-state, and Gaussian-pattern extensions. -/
+
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped BigOperators Topology Matrix Classical ENNReal
+universe u
+namespace InvariantIsing
+
+abbrev Spin (N : ℕ) := Fin N → Bool
+
+def spinValue (b : Bool) : ℝ := if b then 1 else -1
+
+def logPartition {X : Type*} [Fintype X] (H : X → ℝ) : ℝ :=
+  Real.log ((Fintype.card X : ℝ)⁻¹ * ∑ x, Real.exp (H x))
+
+def fieldEnergy {N : ℕ} (c : Fin N → ℝ) (σ : Spin N) : ℝ :=
+  ∑ i, c i * spinValue (σ i)
+
+abbrev Rotation (N : ℕ) :=
+  EuclideanSpace ℝ (Fin N) ≃ₗᵢ[ℝ] EuclideanSpace ℝ (Fin N)
+
+abbrev Orthogonal (N : ℕ) := Matrix.orthogonalGroup (Fin N) ℝ
+
+def spinVector {N : ℕ} (σ : Spin N) : EuclideanSpace ℝ (Fin N) :=
+  WithLp.toLp 2 (fun i => spinValue (σ i))
+
+def rotatedEnergy {N : ℕ} (eig : Fin N → ℝ) (U : Rotation N) (σ : Spin N) : ℝ :=
+  (1 / 2 : ℝ) * ∑ i, eig i * (U (spinVector σ) i) ^ 2
+
+def rotatedPressure {N : ℕ} (eig : Fin N → ℝ) (U : Rotation N)
+    (c : Fin N → ℝ) : ℝ :=
+  (N : ℝ)⁻¹ * logPartition (fun σ => rotatedEnergy eig U σ + fieldEnergy c σ)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+lemma orthogonal_mulVec_norm_sq {N : ℕ} (U : Orthogonal N)
+    (v : EuclideanSpace ℝ (Fin N)) :
+    ‖WithLp.toLp 2 ((U : Matrix (Fin N) (Fin N) ℝ) *ᵥ v.ofLp)‖ ^ 2 = ‖v‖ ^ 2 := by
+  have hU : (U : Matrix (Fin N) (Fin N) ℝ)ᵀ *
+      (U : Matrix (Fin N) (Fin N) ℝ) = 1 :=
+    (Matrix.mem_orthogonalGroup_iff' (Fin N) ℝ).mp U.property
+  rw [EuclideanSpace.real_norm_sq_eq, EuclideanSpace.real_norm_sq_eq]
+  simp only [pow_two]
+  change ((U : Matrix (Fin N) (Fin N) ℝ) *ᵥ v.ofLp) ⬝ᵥ
+      ((U : Matrix (Fin N) (Fin N) ℝ) *ᵥ v.ofLp) = v.ofLp ⬝ᵥ v.ofLp
+  rw [← Matrix.dotProduct_transpose_mulVec, Matrix.mulVec_mulVec, hU,
+    Matrix.one_mulVec]
+
+def matrixRotation {N : ℕ} (U : Orthogonal N) : Rotation N :=
+  { ((WithLp.linearEquiv 2 ℝ (Fin N → ℝ)).trans
+      (Matrix.UnitaryGroup.toLinearEquiv U)).trans
+      (WithLp.linearEquiv 2 ℝ (Fin N → ℝ)).symm with
+    norm_map' := fun v => (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+      (orthogonal_mulVec_norm_sq U v) }
+
+structure OverlapPath where
+  val : ℝ → ℝ
+  monotone : Monotone val
+  nonneg : ∀ s, 0 ≤ val s
+  le_one : ∀ s, val s ≤ 1
+
+instance : CoeFun OverlapPath (fun _ => ℝ → ℝ) := ⟨OverlapPath.val⟩
+
+def pathMeasure : Measure ℝ := volume.restrict (Ioo (0 : ℝ) 1)
+
+def deficit (p : OverlapPath) (r : ℝ) : ℝ :=
+  1 - r - ∫ s, max (p s - r) 0 ∂pathMeasure
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianOperator (a v : ℝ) (f : ℝ → ℝ) (z : ℝ) : ℝ :=
+  if a = 0 then ∫ g, f (z + Real.sqrt v * g) ∂gaussianReal 0 1
+  else a⁻¹ * Real.log (∫ g, Real.exp (a * f (z + Real.sqrt v * g)) ∂gaussianReal 0 1)
+
+structure FieldStep where
+  depth : ℕ
+  cut : Fin (depth + 2) → ℝ
+  ordered_cut : StrictMono cut
+  first : cut 0 = 0
+  last : cut (Fin.last (depth + 1)) = 1
+  height : Fin (depth + 1) → ℝ
+  nonneg : ∀ i, 0 ≤ height i
+  ordered_height : Monotone height
+
+def fieldFunction (h : FieldStep) (s : ℝ) : ℝ :=
+  ∑ i : Fin (h.depth + 1),
+    if h.cut i.castSucc < s ∧ s < h.cut i.succ then h.height i else 0
+
+def fieldIncrement (h : FieldStep) (i : Fin (h.depth + 1)) : ℝ × ℝ :=
+  (h.cut i.castSucc, h.height i -
+    if hi : i.val = 0 then 0 else h.height ⟨i.val - 1, by omega⟩)
+
+def fieldValue (h : FieldStep) (b : ℝ) : ℝ :=
+  ((List.ofFn (fieldIncrement h)).foldr
+    (fun av f => gaussianOperator av.1 av.2 f) (fun z => Real.log (Real.cosh z))) b -
+    h.height (Fin.last h.depth) / 2
+
+def fieldPairing (p : OverlapPath) (h : FieldStep) : ℝ :=
+  ∫ s, p s * fieldFunction h s ∂pathMeasure
+
+def entropyFunctional (p : OverlapPath) : EReal :=
+  ⨆ h : FieldStep, ((fieldValue h 0 + fieldPairing p h / 2 : ℝ) : EReal)
+
+def spectralFunctional (R : ℝ → ℝ) (p : OverlapPath) : ℝ :=
+  (1 / 2 : ℝ) * ∫ r, R (deficit p r) ∂pathMeasure
+
+def variationalFunctional (R : ℝ → ℝ) : EReal :=
+  ⨅ p : OverlapPath, entropyFunctional p + (spectralFunctional R p : EReal)
+
+def measureResolvent (μ : Measure ℝ) (b : ℝ) : ℝ := ∫ y, 1 / (b - y) ∂μ
+
+def measureInverse (μ : Measure ℝ) (e x : ℝ) : ℝ :=
+  if h : ∃ b, e < b ∧ measureResolvent μ b = x then h.choose else e
+
+def measureR (μ : Measure ℝ) (e x : ℝ) : ℝ :=
+  if 0 < x then measureInverse μ e x - 1 / x else ∫ y, y ∂μ
+
+def finiteSpectralMeasure {ι : Type*} (ρ eig : ι → ℝ) : Measure ℝ :=
+  Measure.sum fun a => ENNReal.ofReal (ρ a) • Measure.dirac (eig a)
+
+theorem finiteSpectralMeasure_probability {ι : Type*} [Fintype ι] (ρ eig : ι → ℝ)
+    (hρ : ∀ a, 0 ≤ ρ a) (hsum : ∑ a, ρ a = 1) :
+    IsProbabilityMeasure (finiteSpectralMeasure ρ eig) := by
+  apply HasSum.isProbabilityMeasure_sum_dirac hρ
+  simpa only [hsum] using hasSum_fintype ρ
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+lemma empiricalSpectralWeight_sum {N : ℕ} (hN : 0 < N) :
+    ∑ _i : Fin N, (1 : ℝ)/N=1 := by
+  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+  field_simp
+
+def empiricalSpectralLaw {N : ℕ} (hN : 0 < N) (eig : Fin N → ℝ) : ProbabilityMeasure ℝ :=
+  ⟨finiteSpectralMeasure (fun _ => (1 : ℝ)/N) eig,
+    finiteSpectralMeasure_probability _ _ (fun _ => by positivity) (empiricalSpectralWeight_sum hN)⟩
+
+def spectralMinimum {n : ℕ} (eig : Fin (n+1) → ℝ) : ℝ :=
+  (Finset.univ.image eig).min' (Finset.image_nonempty.mpr Finset.univ_nonempty)
+
+def spectralMaximum {n : ℕ} (eig : Fin (n+1) → ℝ) : ℝ :=
+  (Finset.univ.image eig).max' (Finset.image_nonempty.mpr Finset.univ_nonempty)
+
+def magneticBiasObjective (h : FieldStep) (s b : ℝ) : ℝ := fieldValue h b - b * s
+
+def constrainedFieldValue (h : FieldStep) (s : ℝ) : ℝ :=
+  sInf (range (magneticBiasObjective h s))
+
+def magneticGroupValue {A : Type*} [Fintype A] (γ m : A → ℝ) (h : FieldStep) : ℝ :=
+  ∑ a, γ a * constrainedFieldValue h (m a)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def magneticEntropyFunctional {A : Type*} [Fintype A] (γ m : A → ℝ)
+    (p : OverlapPath) : EReal :=
+  ⨆ h : FieldStep, ((magneticGroupValue γ m h + fieldPairing p h / 2 : ℝ) : EReal)
+
+def magneticVariationalFunctional {A : Type*} [Fintype A] (R : ℝ → ℝ) (γ m : A → ℝ) : EReal :=
+  ⨅ p : OverlapPath, magneticEntropyFunctional γ m p + (spectralFunctional R p : EReal)
+
+def RationalMagnetization (A : Type*) := {m : A → ℚ // ∀ a, |(m a : ℝ)| < 1}
+
+def finiteMagneticFunctional {A : Type*} [Fintype A] (R : ℝ → ℝ) (γ c : A → ℝ) : EReal :=
+  ⨆ m : RationalMagnetization A,
+    ((∑ a, γ a * c a * (m.val a : ℝ) : ℝ) : EReal) +
+      magneticVariationalFunctional R γ (fun a => (m.val a : ℝ))
+
+def finiteIndexWeight {Ω A : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) (g : Ω → A) (a : A) : ℝ := P.real (g ⁻¹' {a})
+
+def simpleFieldIndex {Ω : Type*} [MeasurableSpace Ω] (s : SimpleFunc Ω ℝ) (x : Ω) : s.range :=
+  ⟨s x,s.mem_range_self x⟩
+
+def simpleFieldWeight {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (s : SimpleFunc Ω ℝ) :=
+  finiteIndexWeight P (simpleFieldIndex s)
+
+abbrev SimpleFieldPositive {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (s : SimpleFunc Ω ℝ) :=
+  {i : s.range // 0 < simpleFieldWeight P s i}
+
+def simpleFieldValue {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) [IsProbabilityMeasure P] (s : SimpleFunc Ω ℝ) (R : ℝ → ℝ) : ℝ :=
+  (finiteMagneticFunctional R (fun i : SimpleFieldPositive P s => simpleFieldWeight P s i)
+    (fun i => i.val.val)).toReal
+
+def fieldSimpleApproximation (n : ℕ) : SimpleFunc ℝ ℝ :=
+  SimpleFunc.approxOn id measurable_id (range (id : ℝ → ℝ) ∪ {0}) 0 (by simp) n
+
+def magneticFieldFunctional (spectral : Measure ℝ) (edge : ℝ) (field : ProbabilityMeasure ℝ) : ℝ :=
+  limUnder atTop (fun n => simpleFieldValue (field : Measure ℝ) (fieldSimpleApproximation n)
+    (measureR spectral edge))
+
+structure FieldLawCoupling (μ ν : ProbabilityMeasure ℝ) where
+  law : ProbabilityMeasure (ℝ × ℝ)
+  fst : (law : Measure (ℝ × ℝ)).map Prod.fst = (μ : Measure ℝ)
+  snd : (law : Measure (ℝ × ℝ)).map Prod.snd = (ν : Measure ℝ)
+
+def FieldLawCoupling.cost {μ ν : ProbabilityMeasure ℝ} (p : FieldLawCoupling μ ν) : ℝ≥0∞ :=
+  ∫⁻ xy, ENNReal.ofReal |xy.1-xy.2| ∂(p.law : Measure (ℝ × ℝ))
+
+def fieldWassersteinOne (μ ν : ProbabilityMeasure ℝ) : ℝ≥0∞ :=
+  ⨅ p : FieldLawCoupling μ ν, p.cost
+
+def scaledSpectralLaw (ν : ProbabilityMeasure ℝ) (β : ℝ) : ProbabilityMeasure ℝ :=
+  ν.map (fun x => β*x)
+
+def groundStateEnergy {N : ℕ} (eig : Fin N → ℝ) (U : Rotation N) : ℝ :=
+  (N : ℝ)⁻¹ * Finset.univ.sup' Finset.univ_nonempty (rotatedEnergy eig U)
+
+def thermalVariationalValue (ν : ProbabilityMeasure ℝ) (b β : ℝ) : ℝ :=
+  (variationalFunctional (measureR (scaledSpectralLaw ν β : Measure ℝ) (β*b))).toReal/β
+
+abbrev FieldSpectralData (N : ℕ) := (Fin N → ℝ) × (Fin N → ℝ)
+
+def dataPhysicalPressure {N : ℕ} (d : FieldSpectralData N) (U : Orthogonal N) : ℝ :=
+  rotatedPressure d.1 (matrixRotation U⁻¹) d.2
+
+def ConditionalFieldOrbitLaw {Ω : Type*} [MeasurableSpace Ω] {N : ℕ}
+    (P : Measure Ω) (d : Ω → FieldSpectralData N) (pressure : Ω → ℝ)
+    (H : Measure (Orthogonal N)) : Prop :=
+  P.map (fun ω => (d ω,pressure ω)) =
+    ((P.map d).prod H).map (fun z => (z.1,dataPhysicalPressure z.1 z.2))
+
+def spectralExcess {N : ℕ} (eig : Fin N → ℝ) (a b : ℝ) : ℝ :=
+  (insert 0 (Finset.univ.image (fun i => max (a-eig i) (eig i-b)))).max'
+    (Finset.insert_nonempty 0 _)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+@[irreducible] def gaussianPatternCount (α : ℝ) (N : ℕ) : ℕ := ⌊α*N⌋₊
+
+def marchenkoPasturA (α : ℝ) : ℝ := (1-Real.sqrt α)^2
+
+def marchenkoPasturB (α : ℝ) : ℝ := (1+Real.sqrt α)^2
+
+def marchenkoPasturLower (α : ℝ) : ℝ := if α ≤ 1 then 0 else marchenkoPasturA α
+
+def marchenkoPasturMeasure (α : ℝ) : Measure ℝ :=
+  ENNReal.ofReal (max (1-α) 0) • Measure.dirac 0 +
+    volume.withDensity ((Icc (marchenkoPasturA α) (marchenkoPasturB α)).indicator
+      (fun x => ENNReal.ofReal
+        (Real.sqrt ((marchenkoPasturB α-x)*(x-marchenkoPasturA α))/(2*Real.pi*x))))
+
+def gaussianPatternLimit (α c : ℝ) : ℝ :=
+  (variationalFunctional (measureR ((marchenkoPasturMeasure α).map (fun x => c*x))
+    (max (c*marchenkoPasturLower α) (c*marchenkoPasturB α)))).toReal
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianPatternArray {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m)) :
+    Matrix (Fin N) (Fin m) ℝ := fun i j => z (i,j)
+
+def gaussianPatternSum {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m)) (σ : Spin N) :
+    EuclideanSpace ℝ (Fin m) :=
+  WithLp.toLp 2 ((gaussianPatternArray z)ᵀ *ᵥ (fun i => spinValue (σ i)))
+
+def gaussianPatternPressure {N m : ℕ} (c : ℝ)
+    (z : EuclideanSpace ℝ (Fin N × Fin m)) : ℝ :=
+  (N : ℝ)⁻¹*logPartition (fun σ : Spin N => c/(2*N)*‖gaussianPatternSum z σ‖^2)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianPatternGroundEnergy {N m : ℕ} (ε : ℝ)
+    (z : EuclideanSpace ℝ (Fin N × Fin m)) : ℝ :=
+  (N : ℝ)⁻¹*Finset.univ.sup' Finset.univ_nonempty
+    (fun σ : Spin N => ε/(2*N)*‖gaussianPatternSum z σ‖^2)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianPatternColumn {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m))
+    (i : Fin N) : EuclideanSpace ℝ (Fin m) := WithLp.toLp 2 (fun j => z (i,j))
+
+def gaussianPatternOperator {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m)) :
+    (Fin N → ℝ) →L[ℝ] EuclideanSpace ℝ (Fin m) :=
+  (PiLp.continuousLinearEquiv 2 ℝ (fun _ : Fin m => ℝ)).symm.toContinuousLinearMap.comp
+    ((gaussianPatternArray z)ᵀ.mulVecLin.toContinuousLinearMap)
+
+theorem limiting_pressure_of_extreme_limits_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hmin : Tendsto (fun k => spectralMinimum (eig (k+1))) atTop (𝓝 a))
+    (_hmax : Tendsto (fun k => spectralMaximum (eig (k+1))) atTop (𝓝 b))
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν)),
+    Tendsto (fun N => ∫ ω, rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (fun _ => 0) ∂P)
+      atTop (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) ∧
+    ∀ᵐ ω ∂P, Tendsto (fun N => rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (fun _ => 0))
+      atTop (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem limiting_wasserstein_field_pressure_of_extreme_limits_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hmin : Tendsto (fun k => spectralMinimum (eig (k+1))) atTop (𝓝 a))
+    (_hmax : Tendsto (fun k => spectralMaximum (eig (k+1))) atTop (𝓝 b))
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν))
+    (field : (N : ℕ) → Fin N → ℝ) (ξ : ProbabilityMeasure ℝ)
+    (_hξ : Integrable (fun x : ℝ => x) (ξ : Measure ℝ))
+    (_hw : Tendsto (fun k => fieldWassersteinOne (empiricalSpectralLaw (Nat.succ_pos k) (field (k+1))) ξ)
+      atTop (𝓝 0)),
+    Tendsto (fun N => ∫ ω, rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (field N) ∂P)
+      atTop (𝓝 (magneticFieldFunctional (ν : Measure ℝ) b ξ)) ∧
+    ∀ᵐ ω ∂P, Tendsto (fun N => rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (field N))
+      atTop (𝓝 (magneticFieldFunctional (ν : Measure ℝ) b ξ)) := by
+  sorry
+
+theorem positive_temperature_pressure_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop, ∀ i, a-ε ≤ eig N i ∧ eig N i ≤ b+ε)
+    (β : ℝ) (_hβ : 0 < β)
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν)),
+    Tendsto (fun N => ∫ ω, rotatedPressure (fun i => β*eig N i) (matrixRotation (U N ω)⁻¹) (fun _ => 0) ∂P)
+      atTop (𝓝 (variationalFunctional (measureR (scaledSpectralLaw ν β : Measure ℝ) (β*b))).toReal) ∧
+    ∀ᵐ ω ∂P, Tendsto (fun N => rotatedPressure (fun i => β*eig N i) (matrixRotation (U N ω)⁻¹) (fun _ => 0))
+      atTop (𝓝 (variationalFunctional (measureR (scaledSpectralLaw ν β : Measure ℝ) (β*b))).toReal) := by
+  sorry
+
+theorem ground_state_limit_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop, ∀ i, a-ε ≤ eig N i ∧ eig N i ≤ b+ε)
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν)),
+    ∃ M : ℝ,
+      Tendsto (fun N => ∫ ω, groundStateEnergy (eig N) (matrixRotation (U N ω)⁻¹) ∂P)
+        atTop (𝓝 M) ∧
+      (∀ᵐ ω ∂P, Tendsto (fun N => groundStateEnergy (eig N) (matrixRotation (U N ω)⁻¹))
+        atTop (𝓝 M)) ∧
+      Tendsto (thermalVariationalValue ν b) atTop (𝓝 M) := by
+  sorry
+
+theorem random_pressure_tendsto_in_measure_unconditional
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (eig : (N : ℕ) → Ω → Fin N → ℝ) (Y : ℕ → Ω → ℝ)
+    (heig : ∀ N, Measurable (eig N)) (hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (hlaw : ∀ N, ConditionalFieldOrbitLaw P (fun ω => (eig N ω,fun _ => 0)) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (hcompact : IsCompact (ν : Measure ℝ).support)
+    (hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (ha : a∈(ν : Measure ℝ).support) (hb : b∈(ν : Measure ℝ).support)
+    (hweak : TendstoInMeasure P (fun k ω => LevyProkhorov.ofMeasure
+      (empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1) ω))) atTop
+      (fun _ => LevyProkhorov.ofMeasure ν))
+    (hexcess : TendstoInMeasure P (fun k ω => spectralExcess (eig (k+1) ω) a b)
+      atTop (fun _ => 0)) :
+    TendstoInMeasure P (fun k => Y (k+1)) atTop
+      (fun _ => (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem random_pressure_limit_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (eig : (N : ℕ) → Ω → Fin N → ℝ) (Y : ℕ → Ω → ℝ)
+    (_heig : ∀ N, Measurable (eig N)) (_hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (_hlaw : ∀ N, ConditionalFieldOrbitLaw P (fun ω => (eig N ω,fun _ => 0)) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hweak : TendstoInMeasure P (fun k ω => LevyProkhorov.ofMeasure
+      (empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1) ω))) atTop
+      (fun _ => LevyProkhorov.ofMeasure ν))
+    (_hexcess : TendstoInMeasure P (fun k ω => spectralExcess (eig (k+1) ω) a b)
+      atTop (fun _ => 0))
+    (_hUI : UniformIntegrable (fun k => Y (k+1)) 1 P),
+    TendstoInMeasure P (fun k => Y (k+1)) atTop
+      (fun _ => (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) ∧
+    Tendsto (fun k => eLpNorm (fun ω => Y (k+1) ω-
+      (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) 1 P) atTop (𝓝 0) ∧
+    Tendsto (fun k => ∫ ω, Y (k+1) ω ∂P) atTop
+      (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem random_pressure_tendsto_ae_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (eig : (N : ℕ) → Ω → Fin N → ℝ) (Y : ℕ → Ω → ℝ)
+    (_heig : ∀ N, Measurable (eig N)) (_hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (_hlaw : ∀ N, ConditionalFieldOrbitLaw P (fun ω => (eig N ω,fun _ => 0)) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ᵐ ω ∂P, ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop,
+      ∀ i, a-ε ≤ eig N ω i ∧ eig N ω i ≤ b+ε)
+    (_hweak : ∀ᵐ ω ∂P, Tendsto (fun k =>
+      empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1) ω)) atTop (𝓝 ν)),
+    ∀ᵐ ω ∂P, Tendsto (fun N => Y N ω) atTop
+      (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem random_field_pressure_tendsto_ae_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (d : (N : ℕ) → Ω → FieldSpectralData N) (Y : ℕ → Ω → ℝ)
+    (_hd : ∀ N, Measurable (d N)) (_hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (_hlaw : ∀ N, ConditionalFieldOrbitLaw P (d N) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ᵐ ω ∂P, ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop,
+      ∀ i, a-ε ≤ (d N ω).1 i ∧ (d N ω).1 i ≤ b+ε)
+    (_hweak : ∀ᵐ ω ∂P, Tendsto (fun k =>
+      empiricalSpectralLaw (Nat.succ_pos k) (d (k+1) ω).1) atTop (𝓝 ν))
+    (ξ : ProbabilityMeasure ℝ) (_hξ : Integrable (fun x : ℝ => x) (ξ : Measure ℝ))
+    (_hw : ∀ᵐ ω ∂P, Tendsto (fun k => fieldWassersteinOne
+      (empiricalSpectralLaw (Nat.succ_pos k) (d (k+1) ω).2) ξ) atTop (𝓝 0)),
+    ∀ᵐ ω ∂P, Tendsto (fun N => Y N ω) atTop
+      (𝓝 (magneticFieldFunctional (ν : Measure ℝ) b ξ)) := by
+  sorry
+
+theorem gaussianPattern_pressure_limit_unconditional :
+  ∀ (α : ℝ) (_hα : 0 < α)
+    {Ω : Type u} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (Z : (N : ℕ) → Ω → EuclideanSpace ℝ (Fin N × Fin (gaussianPatternCount α N)))
+    (_hZ : ∀ N, Measurable (Z N)) (_hlaw : ∀ N, HasLaw (Z N) (stdGaussian _) P)
+    (c : ℝ),
+    TendstoInMeasure P (fun k ω => gaussianPatternPressure (N := k+1) (m := gaussianPatternCount α (k+1)) c (Z (k+1) ω)) atTop
+      (fun _ => gaussianPatternLimit α c) ∧
+    Tendsto (fun k => eLpNorm (fun ω => gaussianPatternPressure (N := k+1) (m := gaussianPatternCount α (k+1)) c (Z (k+1) ω)-
+      gaussianPatternLimit α c) 1 P) atTop (𝓝 0) ∧
+    Tendsto (fun k => ∫ ω, gaussianPatternPressure (N := k+1) (m := gaussianPatternCount α (k+1)) c (Z (k+1) ω) ∂P) atTop
+      (𝓝 (gaussianPatternLimit α c)) := by
+  sorry
+
+theorem gaussianPattern_ground_limit_unconditional :
+  ∀ (α : ℝ) (_hα : 0 < α)
+    {Ω : Type u} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (Z : (N : ℕ) → Ω → EuclideanSpace ℝ (Fin N × Fin (gaussianPatternCount α N)))
+    (_hZ : ∀ N, Measurable (Z N)) (_hlaw : ∀ N, HasLaw (Z N) (stdGaussian _) P)
+    (ε : ℝ),
+    ∃ e : ℝ,
+      TendstoInMeasure P (fun k ω => gaussianPatternGroundEnergy ε (Z (k+1) ω)) atTop (fun _ => e) ∧
+      Tendsto (fun k => eLpNorm (fun ω => gaussianPatternGroundEnergy ε (Z (k+1) ω)-e) 1 P)
+        atTop (𝓝 0) ∧
+      Tendsto (fun k => ∫ ω, gaussianPatternGroundEnergy ε (Z (k+1) ω) ∂P) atTop (𝓝 e) ∧
+      Tendsto (fun β => gaussianPatternLimit α (ε*β)/β) atTop (𝓝 e) := by
+  sorry
+
+theorem gaussianPattern_norm_limits_unconditional :
+  ∀ (α : ���) (_hα : 0 < α)
+    {Ω : Type u} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (Z : (N : ℕ) → Ω → EuclideanSpace ℝ (Fin N × Fin (gaussianPatternCount α N)))
+    (_hZ : ∀ N, Measurable (Z N)) (_hlaw : ∀ N, HasLaw (Z N) (stdGaussian _) P),
+    ∃ eplus eminus : ℝ, 0 ≤ eplus ∧ eminus ≤ 0 ∧
+      Tendsto (fun β => gaussianPatternLimit α β/β) atTop (𝓝 eplus) ∧
+      Tendsto (fun β => gaussianPatternLimit α (-β)/β) atTop (𝓝 eminus) ∧
+      (TendstoInMeasure P (fun k ω => ‖gaussianPatternOperator (Z (k+1) ω)‖/(k+1)) atTop
+        (fun _ => Real.sqrt (2*eplus)) ∧
+       Tendsto (fun k => eLpNorm (fun ω => ‖gaussianPatternOperator (Z (k+1) ω)‖/(k+1)-
+        Real.sqrt (2*eplus)) 1 P) atTop (𝓝 0)) ∧
+      (TendstoInMeasure P (fun k ω =>
+        (Finset.univ.inf' Finset.univ_nonempty (fun σ : Spin (k+1) => ‖gaussianPatternSum (Z (k+1) ω) σ‖))/(k+1))
+        atTop (fun _ => Real.sqrt (-2*eminus)) ∧
+       Tendsto (fun k => eLpNorm (fun ω =>
+        (Finset.univ.inf' Finset.univ_nonempty (fun σ : Spin (k+1) => ‖gaussianPatternSum (Z (k+1) ω) σ‖))/(k+1)-
+          Real.sqrt (-2*eminus)) 1 P) atTop (𝓝 0)) := by
+  sorry
+
+end InvariantIsing
+
+end
+
+end OAI
+```
+
+## What to submit
+
+Write `/workspace/Submission.lean`. Start from a copy of the challenge:
+
+```bash
+cp /opt/openai-math/challenges/InvariantIsing.lean /workspace/Submission.lean
+```
+
+then replace every `sorry` with a proof. The file is graded on three things:
+
+- **Same statements.** The theorems `OAI.InvariantIsing.limiting_pressure_of_extreme_limits_unconditional`, `OAI.InvariantIsing.limiting_wasserstein_field_pressure_of_extreme_limits_unconditional`, `OAI.InvariantIsing.positive_temperature_pressure_unconditional`, `OAI.InvariantIsing.ground_state_limit_unconditional`, `OAI.InvariantIsing.random_pressure_tendsto_in_measure_unconditional`, `OAI.InvariantIsing.random_pressure_limit_unconditional`, `OAI.InvariantIsing.random_pressure_tendsto_ae_unconditional`, `OAI.InvariantIsing.random_field_pressure_tendsto_ae_unconditional`, `OAI.InvariantIsing.gaussianPattern_pressure_limit_unconditional`, `OAI.InvariantIsing.gaussianPattern_ground_limit_unconditional`, `OAI.InvariantIsing.gaussianPattern_norm_limits_unconditional` must keep exactly the statement shown above: same names,
+  namespaces, binders and types. Every definition the statements use must stay exactly as written.
+  Change nothing except the proofs.
+- **Standard axioms only.** Proofs may use only `propext`, `Quot.sound` and `Classical.choice`.
+  `sorry`, `admit`, new `axiom`s and `native_decide` (it introduces an axiom of its own) are rejected.
+- **Keep the challenge's declarations as they are.** Put new lemmas and instances *after* the
+  definitions the statements use, or in a separate `Submission/*.lean` module. A declaration added
+  before them can change how they elaborate, and then they no longer match the challenge.
+- **Kernel-checked.** The proofs are re-checked by the Lean kernel, not just the elaborator.
+
+Long proofs can be split into modules under `/workspace/Submission/` (module names
+`Submission.Foo`, `Submission.Foo.Bar`) imported from `Submission.lean`. Only `.lean` files at
+those two paths are graded.
+
+## Environment
+
+- Lean `v4.34.1` and Mathlib at commit `d13f23b` are installed and prebuilt; `/workspace` is a
+  Lake project.
+- The sandbox has 4 CPUs and 8 GB of memory; `LEAN_NUM_THREADS=3` keeps `lake build` to three
+  parallel jobs. Check your work with `cd /workspace && lake build Submission`. Add `#print axioms <name>` to see
+  which axioms a proof uses.
+- There is no internet access. OpenAI's own proofs are not installed.
+
+## Grading
+
+When you finish, `Submission.lean` and `Submission/**.lean` are copied to a fresh machine and
+checked with [Comparator](https://github.com/leanprover/comparator), the Lean FRO's proof checker.
+The reward is 1 if Comparator accepts the proof and 0 otherwise. A partial proof scores 0.

tasks/invariant-ising/solution/reference.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Place openai/math's reference proof as a submission (used by the oracle's solve.sh).
+
+Standalone: the adapter copies this file into every task's solution/ directory.
+
+    reference.py <openai-math lean dir> <closure.txt> <solution module> <workspace>
+
+Each module in closure.txt (``OAI.A.B``) is copied from ``<lean>/OAI/A/B.lean`` to
+``<workspace>/Submission/OAI/A/B.lean`` with ``import OAI.X`` rewritten to
+``import Submission.OAI.X``; ``Submission.lean`` imports the solution module. Declaration names
+are namespaces, not module paths, so the theorems keep the names the challenge expects.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+_IMPORT = re.compile(r"^(\s*(?:public\s+|private\s+)?(?:meta\s+)?import\s+(?:all\s+)?)(OAI(?:\.|\s|$))")
+_HEADER_LINE = re.compile(r"^\s*(?:module\b|prelude\b|--|$)")
+
+
+def rename_imports(text: str) -> str:
+    """Rewrite ``import OAI...`` to ``import Submission.OAI...`` in the import header only."""
+    out, in_header, in_comment = [], True, False
+    for line in text.splitlines(keepends=True):
+        if in_header:
+            stripped = line.strip()
+            if in_comment:
+                in_comment = "-/" not in stripped
+            elif stripped.startswith("/-"):
+                in_comment = "-/" not in stripped[2:]
+            elif _IMPORT.match(line):
+                line = _IMPORT.sub(lambda m: m.group(1) + "Submission." + m.group(2), line, count=1)
+            elif not _HEADER_LINE.match(line) and not re.match(r"^\s*(?:public\s+|private\s+)?(?:meta\s+)?import\s", line):
+                in_header = False
+        out.append(line)
+    return "".join(out)
+
+
+def module_path(root: Path, module: str) -> Path:
+    return root.joinpath(*module.split(".")).with_suffix(".lean")
+
+
+def place(lean_dir: Path, modules: list[str], solution_module: str, workspace: Path) -> None:
+    for module in modules:
+        dst = module_path(workspace / "Submission", module)
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        dst.write_text(rename_imports(module_path(lean_dir, module).read_text(encoding="utf-8")), encoding="utf-8")
+    (workspace / "Submission.lean").write_text(f"import Submission.{solution_module}\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    lean_dir, closure_txt, solution_module, workspace = sys.argv[1:5]
+    modules = [m.strip() for m in Path(closure_txt).read_text().splitlines() if m.strip()]
+    place(Path(lean_dir), modules, solution_module, Path(workspace))
+    print(f"placed {len(modules)} reference modules for {solution_module}")

tasks/invariant-ising/solution/solve.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Oracle: submit openai/math's own proof of InvariantIsing, i.e. module OAI.Probability.InvariantIsing.Unconditional and the
+# 2123 OAI modules it imports, placed under Submission/ (see reference.py).
+set -euo pipefail
+if [ -f /solution/reference.tar.gz ]; then
+  tar -xzf /solution/reference.tar.gz -C /workspace
+else
+  # Fetch only those files at the pinned commit. The task blocks the network while the agent runs,
+  # so run the oracle with `harbor run ... --allow-agent-host github.com`.
+  tmp=$(mktemp -d)
+  git -C "$tmp" init -q
+  git -C "$tmp" remote add origin https://github.com/openai/math.git
+  git -C "$tmp" config core.sparseCheckout true
+  sed -e 's#\.#/#g' -e 's#^#/lean/#' -e 's#$#.lean#' /solution/closure.txt > "$tmp/.git/info/sparse-checkout"
+  git -C "$tmp" fetch -q --depth 1 --filter=blob:none origin adc7f1241b42e322a6451854ab7e4b4c146bf78a
+  git -C "$tmp" checkout -q FETCH_HEAD
+  python3 /solution/reference.py "$tmp/lean" /solution/closure.txt OAI.Probability.InvariantIsing.Unconditional /workspace
+  rm -rf "$tmp"
+fi
+echo "placed the reference proof of InvariantIsing"

tasks/invariant-ising/task.toml

@@ -0,0 +1,49 @@
+schema_version = "1.4"
+
+[task]
+name = "openai-math/invariant-ising"
+version = "1.0.0"
+description = "Prove InvariantIsing (openai/math family 234: All-temperature pressure for orthogonally invariant Ising spin glasses) in Lean 4 with Mathlib; graded by Comparator in a separate sandbox."
+keywords = ["lean4", "mathlib", "theorem-proving", "openai-math", "probability-and-statistical-mechanics"]
+
+[metadata]
+source = "https://github.com/openai/math"
+source_commit = "adc7f1241b42e322a6451854ab7e4b4c146bf78a"
+source_license = "Apache-2.0"
+source_notice = "tests/Challenge.lean is lean/ComparatorChallenges/InvariantIsing.lean from openai/math, (c) OpenAI, unchanged; see NOTICE at the dataset root"
+challenge = "InvariantIsing"
+family = "234"
+family_title = "All-temperature pressure for orthogonally invariant Ising spin glasses"
+subject = "Probability and statistical mechanics"
+theorems = ["OAI.InvariantIsing.limiting_pressure_of_extreme_limits_unconditional", "OAI.InvariantIsing.limiting_wasserstein_field_pressure_of_extreme_limits_unconditional", "OAI.InvariantIsing.positive_temperature_pressure_unconditional", "OAI.InvariantIsing.ground_state_limit_unconditional", "OAI.InvariantIsing.random_pressure_tendsto_in_measure_unconditional", "OAI.InvariantIsing.random_pressure_limit_unconditional", "OAI.InvariantIsing.random_pressure_tendsto_ae_unconditional", "OAI.InvariantIsing.random_field_pressure_tendsto_ae_unconditional", "OAI.InvariantIsing.gaussianPattern_pressure_limit_unconditional", "OAI.InvariantIsing.gaussianPattern_ground_limit_unconditional", "OAI.InvariantIsing.gaussianPattern_norm_limits_unconditional"]
+definition_holes = []
+fixed_definitions = []
+reference_module = "OAI.Probability.InvariantIsing.Unconditional"
+reference_modules = 2123
+reference_lean_bytes = 10537287
+reference_requires_packages = []
+oracle_result = "accepted"
+oracle_grade_seconds = 5030
+difficulty = "research"
+
+[agent]
+timeout_sec = 14400
+network_mode = "no-network"
+
+[environment]
+build_timeout_sec = 5400
+cpus = 4
+memory_mb = 8192
+storage_mb = 10240
+workdir = "/workspace"
+# Lean sees all host CPUs rather than the sandbox's 4; this bounds `lake build` to 3 parallel jobs.
+env = { LEAN_NUM_THREADS = "3" }
+
+[verifier]
+timeout_sec = 21183
+environment_mode = "separate"
+network_mode = "no-network"
+
+[[verifier.collect]]
+command = "python3 /opt/openai-math/pack_submission.py"
+timeout_sec = 300

tasks/invariant-ising/tests/Challenge.lean

@@ -0,0 +1,495 @@
+import Mathlib
+
+namespace OAI
+
+/-! All-temperature invariant Ising pressure and its magnetic, random-spectral,
+ground-state, and Gaussian-pattern extensions. -/
+
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped BigOperators Topology Matrix Classical ENNReal
+universe u
+namespace InvariantIsing
+
+abbrev Spin (N : ℕ) := Fin N → Bool
+
+def spinValue (b : Bool) : ℝ := if b then 1 else -1
+
+def logPartition {X : Type*} [Fintype X] (H : X → ℝ) : ℝ :=
+  Real.log ((Fintype.card X : ℝ)⁻¹ * ∑ x, Real.exp (H x))
+
+def fieldEnergy {N : ℕ} (c : Fin N → ℝ) (σ : Spin N) : ℝ :=
+  ∑ i, c i * spinValue (σ i)
+
+abbrev Rotation (N : ℕ) :=
+  EuclideanSpace ℝ (Fin N) ≃ₗᵢ[ℝ] EuclideanSpace ℝ (Fin N)
+
+abbrev Orthogonal (N : ℕ) := Matrix.orthogonalGroup (Fin N) ℝ
+
+def spinVector {N : ℕ} (σ : Spin N) : EuclideanSpace ℝ (Fin N) :=
+  WithLp.toLp 2 (fun i => spinValue (σ i))
+
+def rotatedEnergy {N : ℕ} (eig : Fin N → ℝ) (U : Rotation N) (σ : Spin N) : ℝ :=
+  (1 / 2 : ℝ) * ∑ i, eig i * (U (spinVector σ) i) ^ 2
+
+def rotatedPressure {N : ℕ} (eig : Fin N → ℝ) (U : Rotation N)
+    (c : Fin N → ℝ) : ℝ :=
+  (N : ℝ)⁻¹ * logPartition (fun σ => rotatedEnergy eig U σ + fieldEnergy c σ)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+lemma orthogonal_mulVec_norm_sq {N : ℕ} (U : Orthogonal N)
+    (v : EuclideanSpace ℝ (Fin N)) :
+    ‖WithLp.toLp 2 ((U : Matrix (Fin N) (Fin N) ℝ) *ᵥ v.ofLp)‖ ^ 2 = ‖v‖ ^ 2 := by
+  have hU : (U : Matrix (Fin N) (Fin N) ℝ)ᵀ *
+      (U : Matrix (Fin N) (Fin N) ℝ) = 1 :=
+    (Matrix.mem_orthogonalGroup_iff' (Fin N) ℝ).mp U.property
+  rw [EuclideanSpace.real_norm_sq_eq, EuclideanSpace.real_norm_sq_eq]
+  simp only [pow_two]
+  change ((U : Matrix (Fin N) (Fin N) ℝ) *ᵥ v.ofLp) ⬝ᵥ
+      ((U : Matrix (Fin N) (Fin N) ℝ) *ᵥ v.ofLp) = v.ofLp ⬝ᵥ v.ofLp
+  rw [← Matrix.dotProduct_transpose_mulVec, Matrix.mulVec_mulVec, hU,
+    Matrix.one_mulVec]
+
+def matrixRotation {N : ℕ} (U : Orthogonal N) : Rotation N :=
+  { ((WithLp.linearEquiv 2 ℝ (Fin N → ℝ)).trans
+      (Matrix.UnitaryGroup.toLinearEquiv U)).trans
+      (WithLp.linearEquiv 2 ℝ (Fin N → ℝ)).symm with
+    norm_map' := fun v => (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+      (orthogonal_mulVec_norm_sq U v) }
+
+structure OverlapPath where
+  val : ℝ → ℝ
+  monotone : Monotone val
+  nonneg : ∀ s, 0 ≤ val s
+  le_one : ∀ s, val s ≤ 1
+
+instance : CoeFun OverlapPath (fun _ => ℝ → ℝ) := ⟨OverlapPath.val⟩
+
+def pathMeasure : Measure ℝ := volume.restrict (Ioo (0 : ℝ) 1)
+
+def deficit (p : OverlapPath) (r : ℝ) : ℝ :=
+  1 - r - ∫ s, max (p s - r) 0 ∂pathMeasure
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianOperator (a v : ℝ) (f : ℝ → ℝ) (z : ℝ) : ℝ :=
+  if a = 0 then ∫ g, f (z + Real.sqrt v * g) ∂gaussianReal 0 1
+  else a⁻¹ * Real.log (∫ g, Real.exp (a * f (z + Real.sqrt v * g)) ∂gaussianReal 0 1)
+
+structure FieldStep where
+  depth : ℕ
+  cut : Fin (depth + 2) → ℝ
+  ordered_cut : StrictMono cut
+  first : cut 0 = 0
+  last : cut (Fin.last (depth + 1)) = 1
+  height : Fin (depth + 1) → ℝ
+  nonneg : ∀ i, 0 ≤ height i
+  ordered_height : Monotone height
+
+def fieldFunction (h : FieldStep) (s : ℝ) : ℝ :=
+  ∑ i : Fin (h.depth + 1),
+    if h.cut i.castSucc < s ∧ s < h.cut i.succ then h.height i else 0
+
+def fieldIncrement (h : FieldStep) (i : Fin (h.depth + 1)) : ℝ × ℝ :=
+  (h.cut i.castSucc, h.height i -
+    if hi : i.val = 0 then 0 else h.height ⟨i.val - 1, by omega⟩)
+
+def fieldValue (h : FieldStep) (b : ℝ) : ℝ :=
+  ((List.ofFn (fieldIncrement h)).foldr
+    (fun av f => gaussianOperator av.1 av.2 f) (fun z => Real.log (Real.cosh z))) b -
+    h.height (Fin.last h.depth) / 2
+
+def fieldPairing (p : OverlapPath) (h : FieldStep) : ℝ :=
+  ∫ s, p s * fieldFunction h s ∂pathMeasure
+
+def entropyFunctional (p : OverlapPath) : EReal :=
+  ⨆ h : FieldStep, ((fieldValue h 0 + fieldPairing p h / 2 : ℝ) : EReal)
+
+def spectralFunctional (R : ℝ → ℝ) (p : OverlapPath) : ℝ :=
+  (1 / 2 : ℝ) * ∫ r, R (deficit p r) ∂pathMeasure
+
+def variationalFunctional (R : ℝ → ℝ) : EReal :=
+  ⨅ p : OverlapPath, entropyFunctional p + (spectralFunctional R p : EReal)
+
+def measureResolvent (μ : Measure ℝ) (b : ℝ) : ℝ := ∫ y, 1 / (b - y) ∂μ
+
+def measureInverse (μ : Measure ℝ) (e x : ℝ) : ℝ :=
+  if h : ∃ b, e < b ∧ measureResolvent μ b = x then h.choose else e
+
+def measureR (μ : Measure ℝ) (e x : ℝ) : ℝ :=
+  if 0 < x then measureInverse μ e x - 1 / x else ∫ y, y ∂μ
+
+def finiteSpectralMeasure {ι : Type*} (ρ eig : ι → ℝ) : Measure ℝ :=
+  Measure.sum fun a => ENNReal.ofReal (ρ a) • Measure.dirac (eig a)
+
+theorem finiteSpectralMeasure_probability {ι : Type*} [Fintype ι] (ρ eig : ι → ℝ)
+    (hρ : ∀ a, 0 ≤ ρ a) (hsum : ∑ a, ρ a = 1) :
+    IsProbabilityMeasure (finiteSpectralMeasure ρ eig) := by
+  apply HasSum.isProbabilityMeasure_sum_dirac hρ
+  simpa only [hsum] using hasSum_fintype ρ
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+lemma empiricalSpectralWeight_sum {N : ℕ} (hN : 0 < N) :
+    ∑ _i : Fin N, (1 : ℝ)/N=1 := by
+  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+  field_simp
+
+def empiricalSpectralLaw {N : ℕ} (hN : 0 < N) (eig : Fin N → ℝ) : ProbabilityMeasure ℝ :=
+  ⟨finiteSpectralMeasure (fun _ => (1 : ℝ)/N) eig,
+    finiteSpectralMeasure_probability _ _ (fun _ => by positivity) (empiricalSpectralWeight_sum hN)⟩
+
+def spectralMinimum {n : ℕ} (eig : Fin (n+1) → ℝ) : ℝ :=
+  (Finset.univ.image eig).min' (Finset.image_nonempty.mpr Finset.univ_nonempty)
+
+def spectralMaximum {n : ℕ} (eig : Fin (n+1) → ℝ) : ℝ :=
+  (Finset.univ.image eig).max' (Finset.image_nonempty.mpr Finset.univ_nonempty)
+
+def magneticBiasObjective (h : FieldStep) (s b : ℝ) : ℝ := fieldValue h b - b * s
+
+def constrainedFieldValue (h : FieldStep) (s : ℝ) : ℝ :=
+  sInf (range (magneticBiasObjective h s))
+
+def magneticGroupValue {A : Type*} [Fintype A] (γ m : A → ℝ) (h : FieldStep) : ℝ :=
+  ∑ a, γ a * constrainedFieldValue h (m a)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def magneticEntropyFunctional {A : Type*} [Fintype A] (γ m : A → ℝ)
+    (p : OverlapPath) : EReal :=
+  ⨆ h : FieldStep, ((magneticGroupValue γ m h + fieldPairing p h / 2 : ℝ) : EReal)
+
+def magneticVariationalFunctional {A : Type*} [Fintype A] (R : ℝ → ℝ) (γ m : A → ℝ) : EReal :=
+  ⨅ p : OverlapPath, magneticEntropyFunctional γ m p + (spectralFunctional R p : EReal)
+
+def RationalMagnetization (A : Type*) := {m : A → ℚ // ∀ a, |(m a : ℝ)| < 1}
+
+def finiteMagneticFunctional {A : Type*} [Fintype A] (R : ℝ → ℝ) (γ c : A → ℝ) : EReal :=
+  ⨆ m : RationalMagnetization A,
+    ((∑ a, γ a * c a * (m.val a : ℝ) : ℝ) : EReal) +
+      magneticVariationalFunctional R γ (fun a => (m.val a : ℝ))
+
+def finiteIndexWeight {Ω A : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) (g : Ω → A) (a : A) : ℝ := P.real (g ⁻¹' {a})
+
+def simpleFieldIndex {Ω : Type*} [MeasurableSpace Ω] (s : SimpleFunc Ω ℝ) (x : Ω) : s.range :=
+  ⟨s x,s.mem_range_self x⟩
+
+def simpleFieldWeight {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (s : SimpleFunc Ω ℝ) :=
+  finiteIndexWeight P (simpleFieldIndex s)
+
+abbrev SimpleFieldPositive {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) (s : SimpleFunc Ω ℝ) :=
+  {i : s.range // 0 < simpleFieldWeight P s i}
+
+def simpleFieldValue {Ω : Type*} [MeasurableSpace Ω]
+    (P : Measure Ω) [IsProbabilityMeasure P] (s : SimpleFunc Ω ℝ) (R : ℝ → ℝ) : ℝ :=
+  (finiteMagneticFunctional R (fun i : SimpleFieldPositive P s => simpleFieldWeight P s i)
+    (fun i => i.val.val)).toReal
+
+def fieldSimpleApproximation (n : ℕ) : SimpleFunc ℝ ℝ :=
+  SimpleFunc.approxOn id measurable_id (range (id : ℝ → ℝ) ∪ {0}) 0 (by simp) n
+
+def magneticFieldFunctional (spectral : Measure ℝ) (edge : ℝ) (field : ProbabilityMeasure ℝ) : ℝ :=
+  limUnder atTop (fun n => simpleFieldValue (field : Measure ℝ) (fieldSimpleApproximation n)
+    (measureR spectral edge))
+
+structure FieldLawCoupling (μ ν : ProbabilityMeasure ℝ) where
+  law : ProbabilityMeasure (ℝ × ℝ)
+  fst : (law : Measure (ℝ × ℝ)).map Prod.fst = (μ : Measure ℝ)
+  snd : (law : Measure (ℝ × ℝ)).map Prod.snd = (ν : Measure ℝ)
+
+def FieldLawCoupling.cost {μ ν : ProbabilityMeasure ℝ} (p : FieldLawCoupling μ ν) : ℝ≥0∞ :=
+  ∫⁻ xy, ENNReal.ofReal |xy.1-xy.2| ∂(p.law : Measure (ℝ × ℝ))
+
+def fieldWassersteinOne (μ ν : ProbabilityMeasure ℝ) : ℝ≥0∞ :=
+  ⨅ p : FieldLawCoupling μ ν, p.cost
+
+def scaledSpectralLaw (ν : ProbabilityMeasure ℝ) (β : ℝ) : ProbabilityMeasure ℝ :=
+  ν.map (fun x => β*x)
+
+def groundStateEnergy {N : ℕ} (eig : Fin N → ℝ) (U : Rotation N) : ℝ :=
+  (N : ℝ)⁻¹ * Finset.univ.sup' Finset.univ_nonempty (rotatedEnergy eig U)
+
+def thermalVariationalValue (ν : ProbabilityMeasure ℝ) (b β : ℝ) : ℝ :=
+  (variationalFunctional (measureR (scaledSpectralLaw ν β : Measure ℝ) (β*b))).toReal/β
+
+abbrev FieldSpectralData (N : ℕ) := (Fin N → ℝ) × (Fin N → ℝ)
+
+def dataPhysicalPressure {N : ℕ} (d : FieldSpectralData N) (U : Orthogonal N) : ℝ :=
+  rotatedPressure d.1 (matrixRotation U⁻¹) d.2
+
+def ConditionalFieldOrbitLaw {Ω : Type*} [MeasurableSpace Ω] {N : ℕ}
+    (P : Measure Ω) (d : Ω → FieldSpectralData N) (pressure : Ω → ℝ)
+    (H : Measure (Orthogonal N)) : Prop :=
+  P.map (fun ω => (d ω,pressure ω)) =
+    ((P.map d).prod H).map (fun z => (z.1,dataPhysicalPressure z.1 z.2))
+
+def spectralExcess {N : ℕ} (eig : Fin N → ℝ) (a b : ℝ) : ℝ :=
+  (insert 0 (Finset.univ.image (fun i => max (a-eig i) (eig i-b)))).max'
+    (Finset.insert_nonempty 0 _)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+@[irreducible] def gaussianPatternCount (α : ℝ) (N : ℕ) : ℕ := ⌊α*N⌋₊
+
+def marchenkoPasturA (α : ℝ) : ℝ := (1-Real.sqrt α)^2
+
+def marchenkoPasturB (α : ℝ) : ℝ := (1+Real.sqrt α)^2
+
+def marchenkoPasturLower (α : ℝ) : ℝ := if α ≤ 1 then 0 else marchenkoPasturA α
+
+def marchenkoPasturMeasure (α : ℝ) : Measure ℝ :=
+  ENNReal.ofReal (max (1-α) 0) • Measure.dirac 0 +
+    volume.withDensity ((Icc (marchenkoPasturA α) (marchenkoPasturB α)).indicator
+      (fun x => ENNReal.ofReal
+        (Real.sqrt ((marchenkoPasturB α-x)*(x-marchenkoPasturA α))/(2*Real.pi*x))))
+
+def gaussianPatternLimit (α c : ℝ) : ℝ :=
+  (variationalFunctional (measureR ((marchenkoPasturMeasure α).map (fun x => c*x))
+    (max (c*marchenkoPasturLower α) (c*marchenkoPasturB α)))).toReal
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianPatternArray {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m)) :
+    Matrix (Fin N) (Fin m) ℝ := fun i j => z (i,j)
+
+def gaussianPatternSum {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m)) (σ : Spin N) :
+    EuclideanSpace ℝ (Fin m) :=
+  WithLp.toLp 2 ((gaussianPatternArray z)ᵀ *ᵥ (fun i => spinValue (σ i)))
+
+def gaussianPatternPressure {N m : ℕ} (c : ℝ)
+    (z : EuclideanSpace ℝ (Fin N × Fin m)) : ℝ :=
+  (N : ℝ)⁻¹*logPartition (fun σ : Spin N => c/(2*N)*‖gaussianPatternSum z σ‖^2)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianPatternGroundEnergy {N m : ℕ} (ε : ℝ)
+    (z : EuclideanSpace ℝ (Fin N × Fin m)) : ℝ :=
+  (N : ℝ)⁻¹*Finset.univ.sup' Finset.univ_nonempty
+    (fun σ : Spin N => ε/(2*N)*‖gaussianPatternSum z σ‖^2)
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+def gaussianPatternColumn {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m))
+    (i : Fin N) : EuclideanSpace ℝ (Fin m) := WithLp.toLp 2 (fun j => z (i,j))
+
+def gaussianPatternOperator {N m : ℕ} (z : EuclideanSpace ℝ (Fin N × Fin m)) :
+    (Fin N → ℝ) →L[ℝ] EuclideanSpace ℝ (Fin m) :=
+  (PiLp.continuousLinearEquiv 2 ℝ (fun _ : Fin m => ℝ)).symm.toContinuousLinearMap.comp
+    ((gaussianPatternArray z)ᵀ.mulVecLin.toContinuousLinearMap)
+
+theorem limiting_pressure_of_extreme_limits_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hmin : Tendsto (fun k => spectralMinimum (eig (k+1))) atTop (𝓝 a))
+    (_hmax : Tendsto (fun k => spectralMaximum (eig (k+1))) atTop (𝓝 b))
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν)),
+    Tendsto (fun N => ∫ ω, rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (fun _ => 0) ∂P)
+      atTop (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) ∧
+    ∀ᵐ ω ∂P, Tendsto (fun N => rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (fun _ => 0))
+      atTop (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem limiting_wasserstein_field_pressure_of_extreme_limits_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hmin : Tendsto (fun k => spectralMinimum (eig (k+1))) atTop (𝓝 a))
+    (_hmax : Tendsto (fun k => spectralMaximum (eig (k+1))) atTop (𝓝 b))
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν))
+    (field : (N : ℕ) → Fin N → ℝ) (ξ : ProbabilityMeasure ℝ)
+    (_hξ : Integrable (fun x : ℝ => x) (ξ : Measure ℝ))
+    (_hw : Tendsto (fun k => fieldWassersteinOne (empiricalSpectralLaw (Nat.succ_pos k) (field (k+1))) ξ)
+      atTop (𝓝 0)),
+    Tendsto (fun N => ∫ ω, rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (field N) ∂P)
+      atTop (𝓝 (magneticFieldFunctional (ν : Measure ℝ) b ξ)) ∧
+    ∀ᵐ ω ∂P, Tendsto (fun N => rotatedPressure (eig N) (matrixRotation (U N ω)⁻¹) (field N))
+      atTop (𝓝 (magneticFieldFunctional (ν : Measure ℝ) b ξ)) := by
+  sorry
+
+theorem positive_temperature_pressure_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop, ∀ i, a-ε ≤ eig N i ∧ eig N i ≤ b+ε)
+    (β : ℝ) (_hβ : 0 < β)
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν)),
+    Tendsto (fun N => ∫ ω, rotatedPressure (fun i => β*eig N i) (matrixRotation (U N ω)⁻¹) (fun _ => 0) ∂P)
+      atTop (𝓝 (variationalFunctional (measureR (scaledSpectralLaw ν β : Measure ℝ) (β*b))).toReal) ∧
+    ∀ᵐ ω ∂P, Tendsto (fun N => rotatedPressure (fun i => β*eig N i) (matrixRotation (U N ω)⁻¹) (fun _ => 0))
+      atTop (𝓝 (variationalFunctional (measureR (scaledSpectralLaw ν β : Measure ℝ) (β*b))).toReal) := by
+  sorry
+
+theorem ground_state_limit_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (U : (N : ℕ) → Ω → Orthogonal N) (_hU : ∀ N, Measurable (U N))
+    (_hHaar : ∀ N, (P.map (U N)).IsMulRightInvariant)
+    (eig : (N : ℕ) → Fin N → ℝ) (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop, ∀ i, a-ε ≤ eig N i ∧ eig N i ≤ b+ε)
+    (_hweak : Tendsto (fun k => empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1)))
+      atTop (𝓝 ν)),
+    ∃ M : ℝ,
+      Tendsto (fun N => ∫ ω, groundStateEnergy (eig N) (matrixRotation (U N ω)⁻¹) ∂P)
+        atTop (𝓝 M) ∧
+      (∀ᵐ ω ∂P, Tendsto (fun N => groundStateEnergy (eig N) (matrixRotation (U N ω)⁻¹))
+        atTop (𝓝 M)) ∧
+      Tendsto (thermalVariationalValue ν b) atTop (𝓝 M) := by
+  sorry
+
+theorem random_pressure_tendsto_in_measure_unconditional
+    {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (eig : (N : ℕ) → Ω → Fin N → ℝ) (Y : ℕ → Ω → ℝ)
+    (heig : ∀ N, Measurable (eig N)) (hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (hlaw : ∀ N, ConditionalFieldOrbitLaw P (fun ω => (eig N ω,fun _ => 0)) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (hcompact : IsCompact (ν : Measure ℝ).support)
+    (hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (ha : a∈(ν : Measure ℝ).support) (hb : b∈(ν : Measure ℝ).support)
+    (hweak : TendstoInMeasure P (fun k ω => LevyProkhorov.ofMeasure
+      (empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1) ω))) atTop
+      (fun _ => LevyProkhorov.ofMeasure ν))
+    (hexcess : TendstoInMeasure P (fun k ω => spectralExcess (eig (k+1) ω) a b)
+      atTop (fun _ => 0)) :
+    TendstoInMeasure P (fun k => Y (k+1)) atTop
+      (fun _ => (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem random_pressure_limit_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (eig : (N : ℕ) → Ω → Fin N → ℝ) (Y : ℕ → Ω → ℝ)
+    (_heig : ∀ N, Measurable (eig N)) (_hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (_hlaw : ∀ N, ConditionalFieldOrbitLaw P (fun ω => (eig N ω,fun _ => 0)) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hweak : TendstoInMeasure P (fun k ω => LevyProkhorov.ofMeasure
+      (empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1) ω))) atTop
+      (fun _ => LevyProkhorov.ofMeasure ν))
+    (_hexcess : TendstoInMeasure P (fun k ω => spectralExcess (eig (k+1) ω) a b)
+      atTop (fun _ => 0))
+    (_hUI : UniformIntegrable (fun k => Y (k+1)) 1 P),
+    TendstoInMeasure P (fun k => Y (k+1)) atTop
+      (fun _ => (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) ∧
+    Tendsto (fun k => eLpNorm (fun ω => Y (k+1) ω-
+      (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) 1 P) atTop (𝓝 0) ∧
+    Tendsto (fun k => ∫ ω, Y (k+1) ω ∂P) atTop
+      (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem random_pressure_tendsto_ae_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (eig : (N : ℕ) → Ω → Fin N → ℝ) (Y : ℕ → Ω → ℝ)
+    (_heig : ∀ N, Measurable (eig N)) (_hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (_hlaw : ∀ N, ConditionalFieldOrbitLaw P (fun ω => (eig N ω,fun _ => 0)) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ᵐ ω ∂P, ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop,
+      ∀ i, a-ε ≤ eig N ω i ∧ eig N ω i ≤ b+ε)
+    (_hweak : ∀ᵐ ω ∂P, Tendsto (fun k =>
+      empiricalSpectralLaw (Nat.succ_pos k) (eig (k+1) ω)) atTop (𝓝 ν)),
+    ∀ᵐ ω ∂P, Tendsto (fun N => Y N ω) atTop
+      (𝓝 (variationalFunctional (measureR (ν : Measure ℝ) b)).toReal) := by
+  sorry
+
+theorem random_field_pressure_tendsto_ae_unconditional :
+  ∀ {Ω : Type*} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (d : (N : ℕ) → Ω → FieldSpectralData N) (Y : ℕ → Ω → ℝ)
+    (_hd : ∀ N, Measurable (d N)) (_hY : ∀ N, Measurable (Y N))
+    (H : (N : ℕ) → Measure (Orthogonal N)) [∀ N, IsProbabilityMeasure (H N)]
+    [∀ N, (H N).IsMulRightInvariant]
+    (_hlaw : ∀ N, ConditionalFieldOrbitLaw P (d N) (Y N) (H N))
+    (ν : ProbabilityMeasure ℝ) (a b : ℝ)
+    (_hcompact : IsCompact (ν : Measure ℝ).support)
+    (_hbound : (ν : Measure ℝ).support ⊆ Icc a b)
+    (_ha : a∈(ν : Measure ℝ).support) (_hb : b∈(ν : Measure ℝ).support)
+    (_hno : ∀ᵐ ω ∂P, ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop,
+      ∀ i, a-ε ≤ (d N ω).1 i ∧ (d N ω).1 i ≤ b+ε)
+    (_hweak : ∀ᵐ ω ∂P, Tendsto (fun k =>
+      empiricalSpectralLaw (Nat.succ_pos k) (d (k+1) ω).1) atTop (𝓝 ν))
+    (ξ : ProbabilityMeasure ℝ) (_hξ : Integrable (fun x : ℝ => x) (ξ : Measure ℝ))
+    (_hw : ∀ᵐ ω ∂P, Tendsto (fun k => fieldWassersteinOne
+      (empiricalSpectralLaw (Nat.succ_pos k) (d (k+1) ω).2) ξ) atTop (𝓝 0)),
+    ∀ᵐ ω ∂P, Tendsto (fun N => Y N ω) atTop
+      (𝓝 (magneticFieldFunctional (ν : Measure ℝ) b ξ)) := by
+  sorry
+
+theorem gaussianPattern_pressure_limit_unconditional :
+  ∀ (α : ℝ) (_hα : 0 < α)
+    {Ω : Type u} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (Z : (N : ℕ) → Ω → EuclideanSpace ℝ (Fin N × Fin (gaussianPatternCount α N)))
+    (_hZ : ∀ N, Measurable (Z N)) (_hlaw : ∀ N, HasLaw (Z N) (stdGaussian _) P)
+    (c : ℝ),
+    TendstoInMeasure P (fun k ω => gaussianPatternPressure (N := k+1) (m := gaussianPatternCount α (k+1)) c (Z (k+1) ω)) atTop
+      (fun _ => gaussianPatternLimit α c) ∧
+    Tendsto (fun k => eLpNorm (fun ω => gaussianPatternPressure (N := k+1) (m := gaussianPatternCount α (k+1)) c (Z (k+1) ω)-
+      gaussianPatternLimit α c) 1 P) atTop (𝓝 0) ∧
+    Tendsto (fun k => ∫ ω, gaussianPatternPressure (N := k+1) (m := gaussianPatternCount α (k+1)) c (Z (k+1) ω) ∂P) atTop
+      (𝓝 (gaussianPatternLimit α c)) := by
+  sorry
+
+theorem gaussianPattern_ground_limit_unconditional :
+  ∀ (α : ℝ) (_hα : 0 < α)
+    {Ω : Type u} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (Z : (N : ℕ) → Ω → EuclideanSpace ℝ (Fin N × Fin (gaussianPatternCount α N)))
+    (_hZ : ∀ N, Measurable (Z N)) (_hlaw : ∀ N, HasLaw (Z N) (stdGaussian _) P)
+    (ε : ℝ),
+    ∃ e : ℝ,
+      TendstoInMeasure P (fun k ω => gaussianPatternGroundEnergy ε (Z (k+1) ω)) atTop (fun _ => e) ∧
+      Tendsto (fun k => eLpNorm (fun ω => gaussianPatternGroundEnergy ε (Z (k+1) ω)-e) 1 P)
+        atTop (𝓝 0) ∧
+      Tendsto (fun k => ∫ ω, gaussianPatternGroundEnergy ε (Z (k+1) ω) ∂P) atTop (𝓝 e) ∧
+      Tendsto (fun β => gaussianPatternLimit α (ε*β)/β) atTop (𝓝 e) := by
+  sorry
+
+theorem gaussianPattern_norm_limits_unconditional :
+  ∀ (α : ℝ) (_hα : 0 < α)
+    {Ω : Type u} [MeasurableSpace Ω] (P : Measure Ω) [IsProbabilityMeasure P]
+    (Z : (N : ℕ) → Ω → EuclideanSpace ℝ (Fin N × Fin (gaussianPatternCount α N)))
+    (_hZ : ∀ N, Measurable (Z N)) (_hlaw : ∀ N, HasLaw (Z N) (stdGaussian _) P),
+    ∃ eplus eminus : ℝ, 0 ≤ eplus ∧ eminus ≤ 0 ∧
+      Tendsto (fun β => gaussianPatternLimit α β/β) atTop (𝓝 eplus) ∧
+      Tendsto (fun β => gaussianPatternLimit α (-β)/β) atTop (𝓝 eminus) ∧
+      (TendstoInMeasure P (fun k ω => ‖gaussianPatternOperator (Z (k+1) ω)‖/(k+1)) atTop
+        (fun _ => Real.sqrt (2*eplus)) ∧
+       Tendsto (fun k => eLpNorm (fun ω => ‖gaussianPatternOperator (Z (k+1) ω)‖/(k+1)-
+        Real.sqrt (2*eplus)) 1 P) atTop (𝓝 0)) ∧
+      (TendstoInMeasure P (fun k ω =>
+        (Finset.univ.inf' Finset.univ_nonempty (fun σ : Spin (k+1) => ‖gaussianPatternSum (Z (k+1) ω) σ‖))/(k+1))
+        atTop (fun _ => Real.sqrt (-2*eminus)) ∧
+       Tendsto (fun k => eLpNorm (fun ω =>
+        (Finset.univ.inf' Finset.univ_nonempty (fun σ : Spin (k+1) => ‖gaussianPatternSum (Z (k+1) ω) σ‖))/(k+1)-
+          Real.sqrt (-2*eminus)) 1 P) atTop (𝓝 0)) := by
+  sorry
+
+end InvariantIsing
+
+end
+
+end OAI

tasks/invariant-ising/tests/grade.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""Grade one openai/math challenge with Comparator.
+
+This runs as root in a separate verifier sandbox that never executed agent code. The only input the
+agent controls is /logs/artifacts/submission.tar. Everything else comes from /tests (this task's
+trusted challenge and Comparator config) and from the image.
+
+Steps:
+  1. Unpack submission.tar, accepting only regular `Submission.lean` / `Submission/**.lean` files.
+  2. Lay out a fresh Lake project: the trusted lakefile, Challenge.lean from /tests, the submission,
+     and the image's prebuilt Mathlib (root-owned, read-only to the grader).
+  3. Run `lake env comparator config.json` as the unprivileged `grader` user, with no network.
+     Comparator builds Challenge and Submission inside landrun, checks that every listed theorem
+     has exactly the challenge's statement, that only the permitted axioms are used, and replays
+     the proof through the Lean kernel.
+  4. Kill everything the grader started, then write the verdict.
+
+reward.txt is 1 only when Comparator prints its success line and exits 0. A rejected or
+non-compiling submission scores 0. A broken grading setup (the trusted Challenge fails to build,
+the network block cannot be installed) writes no reward, so Harbor reports an error instead of a
+score.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import pwd
+import re
+import shutil
+import signal
+import socket
+import stat
+import subprocess
+import sys
+import tarfile
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+TESTS = Path("/tests")
+VERIFIER_DIR = Path("/logs/verifier")
+SUBMISSION_TAR = Path("/logs/artifacts/submission.tar")
+LEAN_ENV = Path("/opt/lean-env")
+RUN_ROOT = Path("/var/lib/oai-grade")
+GRADER = "grader"
+SUCCESS_LINE = "Your solution is okay!"
+GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
+# Lake and Comparator wording when a build process is killed for running out of memory.
+OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
+
+MAX_FILES = 20_000
+MAX_FILE_BYTES = 64 << 20
+MAX_TOTAL_BYTES = 768 << 20
+# Submission.lean, or Submission/A/B.lean where each component is a Lean identifier: it starts with
+# a letter or `_` and continues with letters, digits (subscripts like `₁` included), `_`, `'`, `!`, `?`.
+# Unicode is allowed because Lean identifiers allow it (openai/math has a module named `Kappa₁`).
+_COMPONENT = r"[^\W\d][\w'!?]*"
+MEMBER = re.compile(rf"^Submission(?:/{_COMPONENT})*\.lean$")
+MEMBER_DIR = re.compile(rf"^Submission(?:/{_COMPONENT})*/?$")
+
+LAKEFILE = """import Lake
+open Lake DSL
+
+package openai_math where
+  leanOptions := #[⟨`autoImplicit, false⟩]
+
+require mathlib from git
+  "https://github.com/leanprover-community/mathlib4.git" @ "d13f23b723b8a846827a245b89c10fc7d3f11612"
+
+lean_lib Challenge
+
+-- `Submission` and every `Submission.*` module it imports.
+lean_lib Submission
+"""
+
+
+class Rejected(Exception):
+    """The submission is invalid: reward 0."""
+
+
+class GradingError(Exception):
+    """The grading setup is broken: no reward, so the trial shows as errored."""
+
+
+def toolchain_bin() -> Path:
+    bins = sorted(Path("/opt/elan/toolchains").glob("*/bin"))
+    if len(bins) != 1:
+        raise GradingError(f"expected one Lean toolchain, found {bins}")
+    return bins[0]
+
+
+def unpack_submission(dest: Path) -> dict:
+    """Copy the submission's .lean files into ``dest``; reject anything else."""
+    try:
+        st = SUBMISSION_TAR.lstat()
+    except FileNotFoundError:
+        raise Rejected("no submission: /workspace/Submission.lean was not found after the agent finished")
+    if not SUBMISSION_TAR.is_file() or SUBMISSION_TAR.is_symlink() or st.st_size > MAX_TOTAL_BYTES + (64 << 20):
+        raise Rejected("submission archive is not a regular file of acceptable size")
+
+    files, total = [], 0
+    try:
+        with tarfile.open(SUBMISSION_TAR, "r:") as tar:
+            for count, member in enumerate(tar):
+                if count > MAX_FILES * 2:
+                    raise Rejected(f"submission has more than {MAX_FILES} entries")
+                name = member.name.removeprefix("./")
+                if member.isdir():
+                    if not MEMBER_DIR.match(name):
+                        raise Rejected(f"unexpected directory in submission: {name!r}")
+                    continue
+                if not member.isreg():
+                    raise Rejected(f"only regular .lean files are accepted, got {name!r}")
+                if not MEMBER.match(name):
+                    raise Rejected(f"unexpected file in submission: {name!r} (only Submission.lean and Submission/**.lean)")
+                if member.size > MAX_FILE_BYTES:
+                    raise Rejected(f"{name} is larger than {MAX_FILE_BYTES >> 20} MB")
+                total += member.size
+                if total > MAX_TOTAL_BYTES or len(files) >= MAX_FILES:
+                    raise Rejected("submission is too large")
+                data = tar.extractfile(member).read(MAX_FILE_BYTES + 1)
+                try:
+                    data.decode("utf-8")
+                except UnicodeDecodeError:
+                    raise Rejected(f"{name} is not valid UTF-8")
+                target = dest / name
+                if target.exists():
+                    raise Rejected(f"duplicate entry {name!r}")
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(data)
+                target.chmod(0o644)
+                files.append(name)
+    except tarfile.TarError as exc:
+        raise Rejected(f"submission archive is unreadable: {exc}")
+    if "Submission.lean" not in files:
+        raise Rejected("no submission: /workspace/Submission.lean was not found after the agent finished")
+    for d in (dest / "Submission",):
+        if d.exists():
+            for p in [d, *d.rglob("*")]:
+                if p.is_dir():
+                    p.chmod(0o755)
+    return {"files": len(files), "bytes": total}
+
+
+def write_project(run: Path, config: dict) -> None:
+    (run / "lakefile.lean").write_text(LAKEFILE)
+    shutil.copy(LEAN_ENV / "lake-manifest.json", run / "lake-manifest.json")
+    shutil.copy(LEAN_ENV / "lean-toolchain", run / "lean-toolchain")
+    shutil.copy(TESTS / "Challenge.lean", run / "Challenge.lean")
+    comparator_config = {
+        "challenge_module": "Challenge",
+        "solution_module": "Submission",
+        "theorem_names": config["theorem_names"],
+        "definition_names": config["definition_names"],
+        "permitted_axioms": config["permitted_axioms"],
+        "enable_nanoda": False,
+    }
+    (run / "config.json").write_text(json.dumps(comparator_config, indent=2))
+    lake = run / ".lake"
+    lake.mkdir()
+    (lake / "packages").symlink_to(LEAN_ENV / ".lake" / "packages")
+    for p in run.iterdir():
+        if p.name != ".lake":
+            os.chmod(p, 0o644 if p.is_file() else 0o755, follow_symlinks=False)
+    uid = pwd.getpwnam(GRADER).pw_uid
+    os.chown(lake, uid, uid)
+    os.chmod(run, 0o755)
+
+
+def fresh_run(task: dict) -> Path:
+    """A new, empty Lake project for one grading attempt."""
+    run = Path(tempfile.mkdtemp(prefix="run.", dir=RUN_ROOT))
+    write_project(run, task["comparator"])
+    return run
+
+
+def ensure_readable(roots: tuple[str, ...] = ("/opt/elan", str(LEAN_ENV))) -> int:
+    """Make the prebuilt toolchain and packages readable by the grader (never writable).
+
+    The image already does this; this only repairs an image built without it. It must touch
+    nothing that is already right: these files live in the image's lower overlay layer, and a
+    `chmod` on one copies it whole into the sandbox's writable layer. A blanket `chmod -R` took
+    535 s and used 8.7 GB of the 10 GB working disk. This walk only reads metadata (lstat).
+    Returns the number of entries changed.
+    """
+    changed = 0
+    for root in roots:
+        for dirpath, dirnames, filenames in os.walk(root, followlinks=False):
+            for name in [*dirnames, *filenames]:
+                path = os.path.join(dirpath, name)
+                st = os.lstat(path)
+                if stat.S_ISDIR(st.st_mode):
+                    want = (st.st_mode | 0o555) & ~0o022
+                elif stat.S_ISREG(st.st_mode):
+                    want = (st.st_mode | 0o444) & ~0o022
+                else:
+                    continue
+                if stat.S_IMODE(st.st_mode) != stat.S_IMODE(want):
+                    os.chmod(path, stat.S_IMODE(want))
+                    changed += 1
+    return changed
+
+
+def block_grader_network() -> None:
+    """Reject every socket the grader user opens, loopback included.
+
+    landrun already denies TCP to the sandboxed build. This rule also covers the grader's own
+    processes outside landrun and services listening inside the sandbox.
+    """
+    uid = str(pwd.getpwnam(GRADER).pw_uid)
+    for tool in ("iptables", "ip6tables"):
+        rule = ["OUTPUT", "-m", "owner", "--uid-owner", uid, "-j", "REJECT"]
+        if subprocess.run([tool, "-C", *rule], capture_output=True).returncode == 0:
+            continue
+        res = subprocess.run([tool, "-I", *rule], capture_output=True, text=True)
+        if res.returncode != 0:
+            raise GradingError(f"cannot install the {tool} rule for {GRADER}: {res.stderr.strip()}")
+    probe = subprocess.run(
+        ["runuser", "-u", GRADER, "--", sys.executable, "-c",
+         "import socket,sys\n"
+         "s=socket.socket(); s.settimeout(3)\n"
+         "sys.exit(0 if s.connect_ex(('127.0.0.1', 2280)) == 0 else 1)"],
+        capture_output=True,
+    )
+    if probe.returncode == 0:
+        raise GradingError("the grader user can still open loopback connections")
+
+
+def kill_grader() -> None:
+    for _ in range(20):
+        subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True)
+        if subprocess.run(["pgrep", "-u", GRADER], capture_output=True).returncode != 0:
+            return
+        time.sleep(0.5)
+    raise GradingError("could not stop the grader's processes")
+
+
+def out_of_memory(out: str) -> bool:
+    return any(m in out for m in OOM_MARKERS)
+
+
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
+def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
+    env = {
+        "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
+        "HOME": str(run),
+        "LANG": "C.UTF-8",
+        "LEAN_ABORT_ON_PANIC": "1",
+        # Lean sees every host CPU, not the sandbox's 4; bound Lake's parallel builds so a large
+        # proof fits in 8 GB. Needs the image's Comparator, which passes this into landrun.
+        "LEAN_NUM_THREADS": threads,
+    }
+    cmd = [
+        "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
+        "lake", "env", "comparator", "config.json",
+    ]
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
+    return code, stdout + "\n--- stderr ---\n" + stderr
+
+
+def run_with_timeout(cmd: list[str], cwd: Path, timeout_sec: int, kill_extra=None) -> tuple[int | None, str, str]:
+    """Run ``cmd``; on timeout kill its whole process tree and return code None.
+
+    `timeout(1)` only signals its direct child, so Lean processes started by Lake under landrun
+    kept the output pipe open and the grader waited past Harbor's own limit. Here the command
+    gets its own session; on timeout its process group is killed, and ``kill_extra`` (every
+    process of the grader user) catches anything that left the group.
+    """
+    proc = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                            text=True, errors="replace", start_new_session=True)
+    try:
+        stdout, stderr = proc.communicate(timeout=timeout_sec)
+        return proc.returncode, stdout, stderr
+    except subprocess.TimeoutExpired:
+        try:
+            os.killpg(proc.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+        if kill_extra:
+            kill_extra()
+        stdout, stderr = proc.communicate()
+        return None, stdout, stderr
+
+
+def classify(code: int | None, out: str) -> tuple[int | None, str]:
+    """Map Comparator's result to (reward, reason). reward None means a grading error."""
+    if code == 0 and SUCCESS_LINE in out:
+        return 1, "accepted: statements match, only permitted axioms, kernel replay passed"
+    if "Building Submission" not in out:
+        # Comparator stopped before it touched the submission: the trusted challenge or the
+        # toolchain is broken (or too slow), which says nothing about the agent's proof.
+        return None, ("timed out before the submission was built" if code is None
+                      else "the trusted Challenge failed to build or export")
+    if code is None:
+        return 0, "timed out while building or checking the submission"
+    tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
+    if out_of_memory(out):
+        return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
+    return 0, "rejected: " + " | ".join(tail)[-4000:]
+
+
+def main() -> int:
+    VERIFIER_DIR.mkdir(parents=True, exist_ok=True)
+    os.chmod(VERIFIER_DIR, 0o755)
+    for name in ("reward.txt", "reward.json"):
+        (VERIFIER_DIR / name).unlink(missing_ok=True)
+
+    task = json.loads((TESTS / "task.json").read_text())
+    details: dict = {"task": task["challenge"], "started_at": time.time()}
+    reward: int | None = None
+    log = ""
+    try:
+        RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
+        deadline = time.time() + int(task["grade_timeout_sec"])
+        run = fresh_run(task)
+        details["permission_fixes"] = ensure_readable()
+        block_grader_network()
+        details["submission"] = unpack_submission(run)
+        code, out = run_comparator(run, int(deadline - time.time()))
+        log = out
+        kill_grader()
+        if code not in (0, None) and out_of_memory(out) and deadline - time.time() > 60:
+            # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
+            # in a fresh directory: the first attempt's .lake was written by the submission's own
+            # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
+            run = fresh_run(task)
+            unpack_submission(run)
+            code, out = run_comparator(run, int(deadline - time.time()), threads="1")
+            log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
+            kill_grader()
+            details["retried_single_thread"] = True
+        reward, details["reason"] = classify(code, out)
+        details["comparator_exit"] = code
+    except Rejected as exc:
+        reward, details["reason"] = 0, f"rejected: {exc}"
+    except GradingError as exc:
+        reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
+    finally:
+        try:
+            kill_grader()
+        except GradingError as exc:
+            reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
+    details["reward"] = reward
+    details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
+    (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
+    print(json.dumps(details, indent=2))
+    if reward is not None:
+        (VERIFIER_DIR / "reward.txt").write_text(f"{reward}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/invariant-ising/tests/task.json

@@ -0,0 +1,25 @@
+{
+  "challenge": "InvariantIsing",
+  "comparator": {
+    "theorem_names": [
+      "OAI.InvariantIsing.limiting_pressure_of_extreme_limits_unconditional",
+      "OAI.InvariantIsing.limiting_wasserstein_field_pressure_of_extreme_limits_unconditional",
+      "OAI.InvariantIsing.positive_temperature_pressure_unconditional",
+      "OAI.InvariantIsing.ground_state_limit_unconditional",
+      "OAI.InvariantIsing.random_pressure_tendsto_in_measure_unconditional",
+      "OAI.InvariantIsing.random_pressure_limit_unconditional",
+      "OAI.InvariantIsing.random_pressure_tendsto_ae_unconditional",
+      "OAI.InvariantIsing.random_field_pressure_tendsto_ae_unconditional",
+      "OAI.InvariantIsing.gaussianPattern_pressure_limit_unconditional",
+      "OAI.InvariantIsing.gaussianPattern_ground_limit_unconditional",
+      "OAI.InvariantIsing.gaussianPattern_norm_limits_unconditional"
+    ],
+    "definition_names": [],
+    "permitted_axioms": [
+      "propext",
+      "Quot.sound",
+      "Classical.choice"
+    ]
+  },
+  "grade_timeout_sec": 20283
+}

tasks/invariant-ising/tests/test.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Runs in the separate verifier sandbox, which never ran agent code. See grade.py.
+exec python3 /tests/grade.py

tasks/irrational-rotation/task.toml

@@ -23,7 +23,7 @@ reference_modules = 735
 reference_lean_bytes = 3645017
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1441
+oracle_grade_seconds = 2128
 difficulty = "research"
 
 [agent]

tasks/irrational-rotation/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/irrational-triangle-billiard/task.toml

@@ -23,7 +23,7 @@ reference_modules = 39
 reference_lean_bytes = 594085
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 820
+oracle_grade_seconds = 347
 difficulty = "research"
 
 [agent]

tasks/irrational-triangle-billiard/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/ising-finiteness/task.toml

@@ -23,7 +23,7 @@ reference_modules = 45
 reference_lean_bytes = 1494396
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 958
+oracle_grade_seconds = 327
 difficulty = "research"
 
 [agent]

tasks/ising-finiteness/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/isometric-immersion/task.toml

@@ -23,7 +23,7 @@ reference_modules = 446
 reference_lean_bytes = 2824652
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1242
+oracle_grade_seconds = 698
 difficulty = "research"
 
 [agent]

tasks/isometric-immersion/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/k-median-recovery/task.toml

@@ -23,7 +23,7 @@ reference_modules = 506
 reference_lean_bytes = 3720803
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1362
+oracle_grade_seconds = 1418
 difficulty = "research"
 
 [agent]

tasks/k-median-recovery/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/k-median-refined-recovery/task.toml

@@ -23,7 +23,7 @@ reference_modules = 586
 reference_lean_bytes = 2580016
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1849
+oracle_grade_seconds = 1462
 difficulty = "research"
 
 [agent]

tasks/k-median-refined-recovery/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/k-median-threshold/task.toml

@@ -23,7 +23,7 @@ reference_modules = 765
 reference_lean_bytes = 3236997
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 2259
+oracle_grade_seconds = 2180
 difficulty = "research"
 
 [agent]

tasks/k-median-threshold/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/k-server/task.toml

@@ -23,7 +23,7 @@ reference_modules = 37
 reference_lean_bytes = 1783312
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 587
+oracle_grade_seconds = 322
 difficulty = "research"
 
 [agent]

tasks/k-server/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/kadison-ringrose/task.toml

@@ -23,7 +23,7 @@ reference_modules = 372
 reference_lean_bytes = 2793925
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1352
+oracle_grade_seconds = 1426
 difficulty = "research"
 
 [agent]

tasks/kadison-ringrose/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/kadison-similarity/task.toml

@@ -23,7 +23,7 @@ reference_modules = 816
 reference_lean_bytes = 5791602
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 3415
+oracle_grade_seconds = 4111
 difficulty = "research"
 
 [agent]

tasks/kadison-similarity/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/kahler-splitting/task.toml

@@ -23,7 +23,7 @@ reference_modules = 46
 reference_lean_bytes = 726796
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1239
+oracle_grade_seconds = 468
 difficulty = "research"
 
 [agent]

tasks/kahler-splitting/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/kaplansky-direct-finiteness/task.toml

@@ -23,7 +23,7 @@ reference_modules = 121
 reference_lean_bytes = 544294
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1170
+oracle_grade_seconds = 704
 difficulty = "research"
 
 [agent]

tasks/kaplansky-direct-finiteness/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/kaplansky-finitely-presented/task.toml

@@ -23,7 +23,7 @@ reference_modules = 126
 reference_lean_bytes = 556097
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 1470
+oracle_grade_seconds = 723
 difficulty = "research"
 
 [agent]

tasks/kaplansky-finitely-presented/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None:

tasks/kaplansky-quasitrace/task.toml

@@ -23,7 +23,7 @@ reference_modules = 123
 reference_lean_bytes = 1501004
 reference_requires_packages = []
 oracle_result = "accepted"
-oracle_grade_seconds = 993
+oracle_grade_seconds = 492
 difficulty = "research"
 
 [agent]

tasks/kaplansky-quasitrace/tests/grade.py

@@ -35,6 +35,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import threading
 import time
 from pathlib import Path
 
@@ -46,6 +47,7 @@ RUN_ROOT = Path("/var/lib/oai-grade")
 GRADER = "grader"
 SUCCESS_LINE = "Your solution is okay!"
 GRADE_THREADS = "2"
+SCRATCH_SWEEP_SEC = 15
 # Lake and Comparator wording when a build process is killed for running out of memory.
 OOM_MARKERS = ("Lean exited with code 137", "Child exited with 137")
 
@@ -240,6 +242,49 @@ def out_of_memory(out: str) -> bool:
     return any(m in out for m in OOM_MARKERS)
 
 
+def out_of_disk(out: str) -> bool:
+    return "no space left on device" in out.lower()
+
+
+# Run as the grader user by `empty_build_scratch`. argv: the .lake/build/ir directory.
+EMPTY_SCRATCH = r"""
+import os, sys
+for dirpath, _, files in os.walk(sys.argv[1]):
+    for name in files:
+        if not name.endswith(".setup.json"):
+            continue
+        base = os.path.join(dirpath, name[:-len(".setup.json")])
+        try:
+            # Lake writes X.c.hash once Lean, and leanir if the module needs it, are done with X;
+            # both read X.setup.json, so it may only be emptied after that.
+            if os.stat(base + ".c.hash").st_mtime < os.stat(base + ".setup.json").st_mtime:
+                continue
+            for path in (base + ".setup.json", base + ".c"):
+                if os.path.getsize(path):
+                    os.truncate(path, 0)
+        except OSError:
+            pass
+"""
+
+
+def empty_build_scratch(run: Path, stop: threading.Event) -> None:
+    """Until ``stop`` is set, empty files Lake leaves in .lake/build/ir that grading never reads.
+
+    For every module Lake writes a `.setup.json` (its imports with the path of every .olean they
+    pull in, about 5.5 MB with Mathlib) and the module compiled to C. Neither is used once the
+    module is built, and for proofs of 1,000-2,000 modules they filled the 10 GB disk before the
+    build finished. Lake keeps the recorded hashes, so emptied files do not trigger a rebuild.
+    This runs as the grader user, so it can touch nothing the build could not.
+    """
+    ir = str(run / ".lake" / "build" / "ir")
+    while not stop.wait(SCRATCH_SWEEP_SEC):
+        try:
+            subprocess.run(["runuser", "-u", GRADER, "--", sys.executable, "-c", EMPTY_SCRATCH, ir],
+                           capture_output=True, timeout=600)
+        except subprocess.TimeoutExpired:
+            pass
+
+
 def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) -> tuple[int | None, str]:
     env = {
         "PATH": f"{toolchain_bin()}:/usr/local/bin:/usr/bin:/bin",
@@ -254,10 +299,17 @@ def run_comparator(run: Path, timeout_sec: int, threads: str = GRADE_THREADS) ->
         "runuser", "-u", GRADER, "--", "env", "-i", *(f"{k}={v}" for k, v in env.items()),
         "lake", "env", "comparator", "config.json",
     ]
-    code, stdout, stderr = run_with_timeout(
-        cmd, cwd=run, timeout_sec=timeout_sec,
-        kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
-    )
+    stop = threading.Event()
+    sweeper = threading.Thread(target=empty_build_scratch, args=(run, stop), daemon=True)
+    sweeper.start()
+    try:
+        code, stdout, stderr = run_with_timeout(
+            cmd, cwd=run, timeout_sec=timeout_sec,
+            kill_extra=lambda: subprocess.run(["pkill", "-9", "-u", GRADER], capture_output=True),
+        )
+    finally:
+        stop.set()
+        sweeper.join()
     return code, stdout + "\n--- stderr ---\n" + stderr
 
 
@@ -297,6 +349,8 @@ def classify(code: int | None, out: str) -> tuple[int | None, str]:
     if code is None:
         return 0, "timed out while building or checking the submission"
     tail = [l for l in out.splitlines() if l.strip() and "has local changes" not in l][-25:]
+    if out_of_disk(out):
+        return 0, "rejected: the build ran out of disk space (10 GB) | " + " | ".join(tail)[-3000:]
     if out_of_memory(out):
         return 0, "rejected: the build was killed, most likely out of memory (8 GB) | " + " | ".join(tail)[-3000:]
     return 0, "rejected: " + " | ".join(tail)[-4000:]
@@ -311,6 +365,7 @@ def main() -> int:
     task = json.loads((TESTS / "task.json").read_text())
     details: dict = {"task": task["challenge"], "started_at": time.time()}
     reward: int | None = None
+    log = ""
     try:
         RUN_ROOT.mkdir(mode=0o711, parents=True, exist_ok=True)
         deadline = time.time() + int(task["grade_timeout_sec"])
@@ -325,26 +380,33 @@ def main() -> int:
             # Two Lean processes in parallel can exceed 8 GB on a heavy module. Retry once with one,
             # in a fresh directory: the first attempt's .lake was written by the submission's own
             # build and must not be trusted for the challenge.
+            shutil.rmtree(run, ignore_errors=True)
             run = fresh_run(task)
             unpack_submission(run)
             code, out = run_comparator(run, int(deadline - time.time()), threads="1")
             log += "\n\n=== retried with one Lean process after running out of memory ===\n\n" + out
             kill_grader()
             details["retried_single_thread"] = True
-        (VERIFIER_DIR / "comparator.log").write_text(log)
         reward, details["reason"] = classify(code, out)
         details["comparator_exit"] = code
     except Rejected as exc:
         reward, details["reason"] = 0, f"rejected: {exc}"
     except GradingError as exc:
         reward, details["reason"] = None, f"grading error: {exc}"
+    except Exception as exc:
+        reward, details["reason"] = None, f"grading error: {type(exc).__name__}: {exc}"
     finally:
         try:
             kill_grader()
         except GradingError as exc:
             reward, details["reason"] = None, f"grading error: {exc}"
+        # Free the build before writing anything. A build that filled the disk would otherwise
+        # make these writes fail, and with no space left the sandbox cannot report that the
+        # verifier exited, so Harbor waits until its own timeout and records no verdict.
+        shutil.rmtree(RUN_ROOT, ignore_errors=True)
     details["reward"] = reward
     details["finished_at"] = time.time()
+    (VERIFIER_DIR / "comparator.log").write_text(log)
     (VERIFIER_DIR / "grading.json").write_text(json.dumps(details, indent=2))
     print(json.dumps(details, indent=2))
     if reward is not None: