openai/math as Harbor environments: 355 validated tasks

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSE-openai-math

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,38 @@
+openai-math-harbor
+==================
+
+This dataset packages the Lean statements of OpenAI's "openai/math" release as Harbor tasks.
+
+Redistributed material
+----------------------
+Each task's tests/Challenge.lean, and the Lean block quoted in its instruction.md, is the file
+lean/ComparatorChallenges/<Name>.lean from https://github.com/openai/math at commit
+adc7f1241b42e322a6451854ab7e4b4c146bf78a, copyright OpenAI, licensed under the Apache License, Version 2.0 (see
+LICENSE-openai-math). The files are unchanged.
+
+Modified material
+-----------------
+The Comparator configuration of each task (tests/task.json) is derived from the corresponding
+lean/ComparatorChallenges/<Name>.json in that repository. In eight tasks, definitions that the
+original listed under "definition_names" although their bodies are written out were removed from
+that list, so that Comparator requires them to match exactly; task.toml records them under
+[metadata] fixed_definitions.
+
+Only statements whose official proof was verified in the environment are included; the README
+lists the others and why each could not be validated. One challenge (DefocusingNLS) is left out
+by design.
+
+Not included
+------------
+OpenAI's proofs (the lean/OAI library) are not part of this dataset.
+
+Everything else in this dataset (task.toml, instruction.md apart from the quoted statement,
+tests/grade.py, tests/test.sh, environment/, solution/, generator/) is licensed under the
+Apache License, Version 2.0 (see LICENSE).
+
+Third-party software in the sandbox image
+-----------------------------------------
+Lean 4 and Mathlib (Apache-2.0); Comparator and lean4export by the Lean FRO (Apache-2.0),
+Comparator built from leanprover/comparator@d03acab with a one-line patch that passes
+LEAN_NUM_THREADS into its sandbox; landrun (MIT). The image is built from environment/ at run
+time; none of this software is stored in the dataset.

README.md

@@ -0,0 +1,202 @@
+---
+license: apache-2.0
+task_categories:
+- other
+tags:
+- harbor
+- rl-environment
+- reinforcement-learning
+- code-agent
+- lean4
+- mathlib
+- theorem-proving
+- openai-math
+pretty_name: "openai/math as Harbor environments"
+---
+
+# openai/math as Harbor environments
+
+> **Experimental.** Built on a research release that is itself new and not yet independently
+> reviewed. Expect rough edges, and read any proof that scores 1 before relying on it.
+
+We ported the math problems from OpenAI's [openai/math](https://github.com/openai/math) release
+(commit `adc7f12`) into [Harbor](https://github.com/harbor-framework/harbor) environments.
+The release formalizes **405** of its results as Lean statements. This dataset contains
+**355 environments**, the ones whose official proof we verified end to end in the environment,
+covering 209 result families across 17 fields. The other 50 are listed
+under [Validation](#validation) with the reason each could not be validated.
+
+## How a task works
+
+The agent gets a sandbox with Lean 4 and a prebuilt Mathlib, no internet, and one of OpenAI's
+theorems written in Lean with `sorry` where the proof should be.
+
+**What `sorry` means.** In Lean, `sorry` is a placeholder for a missing proof: it lets the file
+compile as if the step were proven, but nothing has actually been shown, and Lean flags it. The
+statement is given exactly as OpenAI formalized it, and the agent's job is to replace every `sorry`
+with a real proof.
+
+When the agent finishes, a separate, fresh sandbox checks its proof with
+[Comparator](https://github.com/leanprover/comparator), the Lean FRO's proof checker:
+
+- **reward 1** if the theorem has exactly the original statement, the proof uses only Lean's
+  standard axioms (`propext`, `Quot.sound`, `Classical.choice`, so no leftover `sorry` and no new
+  axioms), and the Lean kernel accepts it;
+- **reward 0** otherwise.
+
+OpenAI's own proofs serve as the reference solutions: Harbor's oracle fetches them from GitHub at
+run time. They are not included here and the agent never sees them.
+
+## A strict reward
+
+The grader only accepts a complete proof of the statement exactly as OpenAI formalized it. That
+makes it hard to game, but it is also a real limitation for problems like these:
+
+- a correct proof of an equivalent statement, written with different definitions or a different
+  formulation, scores 0;
+- partial progress (useful lemmas, a proof of a special case, a correct strategy with a gap) scores 0;
+- nothing rewards a creative approach unless it ends in a complete proof of this exact statement.
+
+For open research problems, a more general reward function that recognizes any valid solution to the
+underlying problem, including creative reformulations and partial progress, would be a better
+training signal. We use the strict check here because it is precise and cannot be fooled; treat it
+as one end of that design space.
+
+## What's included
+
+- `tasks/` — one Harbor task per validated problem: instruction, Lean statement, sandbox image recipe,
+  verifier and oracle
+- `registry.json` — Harbor registry entry (`openai-math-harbor@1.0`)
+- `manifest.parquet` — one row per task: field, family, theorem names, reference-proof size, oracle
+  result
+- `generator/` — the code that builds the sandbox image and regenerates the tasks from openai/math
+- `LICENSE`, `NOTICE`, `LICENSE-openai-math` — licensing and attribution
+
+## Run it with the Harbor CLI
+
+You need Harbor 0.24+ with the Daytona backend (`DAYTONA_API_KEY`, `DAYTONA_API_URL`) and
+credentials for the agent you run.
+
+```bash
+pip install "harbor[daytona]>=0.24" daytona
+hf download FineEnvs/openai-math-harbor --repo-type dataset --local-dir openai-math-harbor
+cd openai-math-harbor
+
+# Build the shared sandbox image once (Lean 4, Mathlib, Comparator; ~9 GB, about an hour).
+(cd generator && python -m openai_math_harbor.snapshot)
+SNAP=$(cd generator && python -m openai_math_harbor.snapshot --print-name)
+
+# Run any agent Harbor supports (`harbor agent list`) on a few tasks:
+harbor run -p tasks -e daytona --ek snapshot_template_name=$SNAP \
+  -a <agent> -m <model> -i plane-coloring -i hilbert-crouzeix -n 2
+
+# Check that the grader accepts OpenAI's own proof of a task:
+harbor run -p tasks -e daytona --ek snapshot_template_name=$SNAP \
+  -a oracle --allow-agent-host github.com -i plane-coloring
+```
+
+Each task asks for 4 CPUs, 8 GB of memory and 10 GB of disk, and gives the agent 4 hours. Task
+names are the folder names under `tasks/`.
+
+## Validation
+
+We generated a task for every statement except one left out by design (`DefocusingNLS`, whose
+statement has a `sorry` inside a definition its theorems depend on), and ran Harbor's oracle on each:
+it submits OpenAI's own proof and has it graded by the same verifier an agent faces. Only tasks whose
+official proof was accepted are included.
+
+| Oracle result | Tasks | Meaning |
+|---|---|---|
+| accepted | 355 | OpenAI's proof is accepted: the environment is verified end to end |
+| missing-package | 16 | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| definition-mismatch | 2 | OpenAI's proof writes a definition with the same text but it compiles differently, so the exact-match check fails |
+| memory | 5 | OpenAI's proof needs more than the sandbox's 8 GB of memory to build |
+| disk | 4 | OpenAI's proof is too large for the sandbox's 10 GB disk |
+| not completed | 22 | grading did not complete in our run |
+
+Grading an accepted proof took 16 minutes at the median. Each task's result is in its `task.toml` (`oracle_result`) and in `manifest.parquet`.
+
+<details><summary>50 statements not included (click to expand)</summary>
+
+| Statement | Why it could not be validated |
+|---|---|
+| `arnold-counterexample` | OpenAI's proof needs more than the sandbox's 8 GB of memory to build |
+| `atomic-gaussian` | grading did not complete in our run |
+| `catalan` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `coarse-assembly` | OpenAI's proof needs more than the sandbox's 8 GB of memory to build |
+| `continuum-coulomb-hardness` | OpenAI's proof is too large for the sandbox's 10 GB disk |
+| `cycle-clique-ramsey` | grading did not complete in our run |
+| `defocusing-nls` | left out by design: OAI.DefocusingNLS.sobolevProduct: open definition the theorem statements depend on |
+| `dirichlet-seven-eighths` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `duke-prime-degree` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `einstein-four` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `erdos-reciprocal` | OpenAI's proof is too large for the sandbox's 10 GB disk |
+| `hecke-seven-eighths` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `invariant-ising` | grading did not complete in our run |
+| `jacobsthal` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `jacobsthal-improved` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `joint-dickman` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `koebe-circle-domains` | OpenAI's proof is too large for the sandbox's 10 GB disk |
+| `matrix-multiplication` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `mub-six` | grading did not complete in our run |
+| `nuclear-ultrapower` | OpenAI's proof needs more than the sandbox's 8 GB of memory to build |
+| `occupied-overlap` | OpenAI's proof writes a definition with the same text but it compiles differently, so the exact-match check fails |
+| `ordinary-two-point-correlations` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `ostmann-complete` | grading did not complete in our run |
+| `ostmann-primes` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `patterson-first-moment` | OpenAI's proof is too large for the sandbox's 10 GB disk |
+| `planar-packing` | grading did not complete in our run |
+| `polycyclic-recognition` | grading did not complete in our run |
+| `quasi-riemann-hypothesis` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `ramsey-five` | grading did not complete in our run |
+| `riesz-quantitative` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `sat-computability` | grading did not complete in our run |
+| `sharp-log-ramsey` | grading did not complete in our run |
+| `siegel-zeros` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `simple-amenable` | grading did not complete in our run |
+| `simple-overgroups` | grading did not complete in our run |
+| `sk-barriers` | grading did not complete in our run |
+| `sk-high-temperature` | grading did not complete in our run |
+| `sk-ratio` | grading did not complete in our run |
+| `smooth-yau` | grading did not complete in our run |
+| `snaky-certificate` | OpenAI's proof needs more than the sandbox's 8 GB of memory to build |
+| `snaky-conditional` | grading did not complete in our run |
+| `snaky-twenty-one` | grading did not complete in our run |
+| `spin-angle` | OpenAI's proof writes a definition with the same text but it compiles differently, so the exact-match check fails |
+| `standard-map-components` | grading did not complete in our run |
+| `strong-kadison-kastler` | grading did not complete in our run |
+| `surface-immersion` | grading did not complete in our run |
+| `taming-compatibility` | grading did not complete in our run |
+| `totient-asymptotic` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `totient-companion-zero` | OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include |
+| `universal-tensor-squares` | OpenAI's proof needs more than the sandbox's 8 GB of memory to build |
+
+</details>
+
+The verifier was also tested against submissions that try to cheat (`sorry` in several disguises,
+fake axioms, `native_decide`, weakened statements, redefined definitions, planted reward files, code
+that runs during grading). All scored 0. A no-op agent scores 0.
+
+## Notes
+
+- **Configs.** In eight of openai/math's Comparator configs, definitions written out in the statement
+  were listed as "holes" that Comparator does not check, so a solution could redefine them. Here they
+  must match exactly; affected tasks list them under `fixed_definitions` in `task.toml`.
+- **Contamination.** The statements and proofs have been public since 6 October 2026.
+- **Difficulty.** These are open research problems; expect reward 0 on almost every task.
+
+Technical details (grading design, threat model, image recipe) are in `generator/README.md`.
+
+## License
+
+- The Lean statements are copied unchanged from [openai/math](https://github.com/openai/math)
+  (© OpenAI), licensed under the
+  [Apache License 2.0](https://github.com/openai/math/blob/main/LICENSE); see `LICENSE-openai-math`
+  and `NOTICE`. OpenAI's proofs are not redistributed.
+- The packaging, verifier and generator are Apache-2.0 (`LICENSE`).
+- The sandbox image is built from [Lean 4](https://github.com/leanprover/lean4) and
+  [Mathlib](https://github.com/leanprover-community/mathlib4) (Apache-2.0),
+  [Comparator](https://github.com/leanprover/comparator) and
+  [lean4export](https://github.com/leanprover/lean4export) (Apache-2.0), and
+  [landrun](https://github.com/Zouuup/landrun) (MIT).
+- If you use the results, cite the openai/math manuscripts as that repository asks.

generator/README.md

@@ -0,0 +1,160 @@
+# Generator and verifier: technical notes
+
+This directory produces the Harbor tasks in `../tasks/` from a checkout of
+[openai/math](https://github.com/openai/math), builds the sandbox image they run in, and contains
+the verifier. The dataset card (`../README.md`) covers what the environment is and how to run it;
+this file covers how the tasks are generated and graded, the threat model, and the checks behind
+the validation.
+
+## Layout
+
+```
+openai_math_harbor/
+  challenges.py      reads the challenges, maps them to families, applies the hole policy
+  import_graph.py    import graph of the openai/math Lean library (reference-proof closures)
+  oracle.py          closure and packaging of the reference proofs
+  reference.py       places a reference proof as a submission (copied into each task's solution/)
+  adapter.py         writes tasks/, registry.json, manifest.parquet, the card and NOTICE
+  snapshot.py        builds the shared Daytona snapshot from image/
+  report.py          turns a Harbor oracle job into per-task verdicts
+  attacks.py         adversarial submissions used to test the verifier
+  templates/         instruction, verifier (tests/grade.py, test.sh), oracle (solve.sh), card
+image/               Dockerfile and setup scripts for the shared image (= every task's environment/)
+tests/               unit tests for the verifier's submission handling
+```
+
+## Regenerating the tasks
+
+```bash
+# A sparse checkout of openai/math at the pinned commit:
+git init openai-math && cd openai-math
+git remote add origin https://github.com/openai/math.git
+git sparse-checkout set --no-cone /lean/ComparatorChallenges/ /lean/docs/ /overview.tex /LICENSE
+git fetch --depth 1 --filter=blob:none origin adc7f1241b42e322a6451854ab7e4b4c146bf78a && git checkout FETCH_HEAD
+cd ..
+
+# Optional: the import graph, for reference-proof sizes and the oracle's file lists. Needs the full
+# lean/ directory (about 1.8 GB checked out).
+python -m openai_math_harbor.import_graph openai-math/lean graph.json
+
+python -m openai_math_harbor.adapter --openai-math openai-math --graph graph.json --out out/
+# Stamp oracle verdicts into the tasks after an oracle run:
+python -m openai_math_harbor.report <harbor job dir> oracle_results.json
+python -m openai_math_harbor.adapter ... --oracle-results oracle_results.json
+```
+
+Every challenge goes through the same code; no task is written by hand. Three things are decided
+per challenge, all from the data:
+
+| What | Count | Handling |
+|---|---|---|
+| Definition holes | 9 configs | Comparator checks only the name and type of a `definition_names` entry, never its body, so a solution could redefine `ProperColoring := False` and prove the theorem trivially. A hole whose body is written out is removed from the config, so it must match exactly (8 configs). A hole whose body is `sorry` stays open only if its name appears nowhere else in the file (`ElementaryPositivity`, whose type is the claim). `DefocusingNLS` has a `sorry` inside a definition the theorems use and is excluded. |
+| Reference proofs needing other Lean libraries | 23 | PrimeNumberTheoremAnd, StrongPNT, RellichKondrachov and others. Every statement imports only Mathlib, so agents are unaffected; only those official proofs cannot be built in this image. |
+| Grading time | all | 1 h plus 15 min per MB of the reference proof, at most 6 h. |
+
+The 137 result families without Lean statements have no machine-checkable target and are not part
+of the dataset.
+
+## How a trial runs
+
+```
+agent sandbox (snapshot)                    verifier sandbox (same snapshot, fresh)
+  /workspace  Lake project, Mathlib           never runs agent code
+  agent writes Submission.lean                 /tests: Challenge.lean, task.json, grade.py
+  (+ Submission/**.lean)                       /logs/artifacts/submission.tar  <- only input
+  no network while the agent runs                1. accept regular Submission*.lean files only
+        |                                        2. fresh Lake project, prebuilt read-only Mathlib
+  collect hook: pack_submission.py               3. iptables: grader uid gets no sockets
+  -> /logs/artifacts/submission.tar ---------->  4. Comparator as `grader`: landrun builds, statement
+     (one plain file crosses)                       + axiom check, kernel replay
+                                                 5. kill grader processes, root writes reward.txt
+```
+
+Harbor's `[verifier] environment_mode = "separate"` (0.24+) provides the second sandbox. Both
+sandboxes start from one Daytona snapshot built from `image/Dockerfile`; every task carries the
+identical `environment/`, so the image is built once. Harbor's own Daytona auto-snapshot gives up
+after 10 minutes, which is less than the image build takes, hence `snapshot.py`.
+
+## Threat model
+
+| Attempt | What stops it | Test |
+|---|---|---|
+| `sorry`, `admit`, a tactic macro that expands to `sorry` | `sorryAx` is not a permitted axiom | `sorry`, `sorry-macro` |
+| Declare `axiom cheat : False` | only `propext`, `Quot.sound`, `Classical.choice` allowed | `axiom` |
+| `implemented_by` + `native_decide` to prove `False` | `native_decide` introduces an axiom of its own | `native-decide-false` |
+| Same theorem name, weaker statement | the statement must equal the challenge's exactly | `weaken-statement` |
+| Redefine a definition the statement uses | every constant in the statement must match; openai/math's loose hole configs are tightened | `redefine-definition` |
+| Keep a structure's name and type but drop a proof obligation from its fields | Comparator also compares the structure's constructor, whose type lists the fields | `tamper-structure` |
+| Re-export the trusted Challenge module | its theorems are `sorry` | `import-challenge` |
+| Plant `reward.txt` or a fake `comparator` in the agent sandbox | grading runs in a separate fresh sandbox | `agent-side-reward` |
+| Lean code run while the verifier builds the proof (`run_cmd`, `#eval`, macros) writes `reward.txt`, runs a shell or opens a connection | landrun (read-only file system except `.lake`, execution limited to Lean and git, TCP denied), unprivileged `grader` user, iptables owner rule; root writes the reward only after killing every grader process | `compile-time-reward` |
+| Symlinks, path traversal, device files, hard links, huge archives | the collect hook packs only regular files; `grade.py` accepts only regular `Submission.lean` and `Submission/**.lean` whose path components are Lean identifiers | `symlink`, `tests/test_grade_unpack.py` |
+| Read OpenAI's proof | not in the image; the agent phase has no network | network probe (below) |
+| A background process in the agent sandbox interfering with grading | Harbor stops the agent sandbox before the verifier starts and empties the verifier's log directory first; on Daytona the two sandboxes share no files | by construction |
+| A Lean kernel soundness bug | not covered (Comparator's second kernel, nanoda, is off) | none |
+| Memorized public proofs | not covered | none |
+
+Grading fails closed: a rejected or non-compiling submission scores 0. If the trusted side breaks
+(the Challenge fails to build, or times out before the submission is reached, or the network block
+cannot be installed), no reward is written and Harbor reports the trial as an error rather than 0.
+
+**What each isolation layer was shown to do** on Daytona's kernel (Linux 6.17): under landrun, the
+grader's build cannot write outside the build directory and gets `EACCES` on TCP connects. Without
+landrun, the grader user *can* reach Daytona's in-sandbox control service on port 2280, so
+`grade.py` also installs an iptables rule for that user before Comparator runs and refuses to grade
+if the rule does not take effect.
+
+**Trusted, not re-checked here:** the Lean kernel, Comparator's export parser and `lean4export` (a
+crafted `.olean` written at build time is only accepted if the kernel replay accepts it), landrun,
+and Daytona's sandbox boundary.
+
+## Checks behind the validation
+
+All through `harbor run` on Daytona with the separate verifier; none involves a language model.
+
+| Check | Expected | Result |
+|---|---|---|
+| Oracle over every task (official proofs) | 1 where the proof fits the image | see the dataset card and each task's `oracle_result` |
+| All 405 statements built in one sandbox (`lake build`, 3 threads) | compile | 405 of 405; median 5 s, 90th percentile 7 s, slowest 220 s |
+| No-op agent | 0 | 0, "no submission" |
+| 11 adversarial submissions (`attacks.py`) | 0 | 0 on all eleven, each rejected for the intended reason; the build-time probe printed `write denied`, and neither a shell nor git's HTTP helper could be executed |
+| Agent-phase view (oracle agent printing its environment) | no network | DNS fails, HTTPS to github.com times out, a direct-IP connection is refused; `LEAN_NUM_THREADS=3` is set; `/tests` is absent |
+| Oracle with `--allow-agent-host github.com` | 1 | 1 (positive control for the network check) |
+| landrun and iptables in a Daytona sandbox | both enforce | as described above |
+
+## The image
+
+`image/lean_setup.sh` installs Lean v4.34.1 and Mathlib at the commits openai/math pins, builds
+Comparator (`leanprover/comparator@d03acab`) and lean4export with the same toolchain, builds landrun,
+copies every challenge statement to `/opt/openai-math/challenges/`, and prepares `/workspace`. Three
+details matter:
+
+- **Size.** Lean plus Mathlib is about 11 GB as installed, more than a 10 GB Daytona sandbox. The
+  script drops what importing Mathlib never reads: static libraries, LLVM and gcc (needed only to link
+  the executables built earlier in the script), and Mathlib's generated C and `.ilean` files,
+  truncated with their `.hash` files kept so Lake still treats Mathlib as built. A smoke test fails
+  the build if a second `lake build` still compiles any dependency.
+- **Threads.** Lean sees every host CPU (64 on Daytona), not the sandbox's 4, so by default Lake
+  starts one Mathlib-loaded `lean` per module and runs out of memory. Agents get
+  `LEAN_NUM_THREADS=3` (`task.toml`); the verifier uses 2, which reaches Comparator's landrun
+  sandbox through a one-line `sed` patch to Comparator's `envPass` lists.
+- **Permissions.** Mathlib's cache tool unpacks files as mode 0600. The script makes the toolchain
+  and packages world-readable (still root-owned), and a second smoke test builds as the `grader` user.
+
+## Limits
+
+- **Daytona's per-sandbox caps: 4 CPUs, 8 GB memory, 10 GB disk.** The 10 GB is working space on
+  top of the image. Compiled output of a large proof can exceed it: reference proofs up to about
+  1.8 MB of Lean source grade fine, while 3.5 MB and 4.8 MB ones ran out of disk. The oracle results
+  record which tasks are affected. Higher per-sandbox limits remove the constraint.
+- **The agent sandbox contains Comparator,** since agent and verifier share one image. Nothing in it
+  is secret: the statement and the rules are public, and `lake build` plus `#print axioms` already
+  tell an agent whether a proof is complete.
+- **Difficulty.** These are open research problems; expect a reward of 0 on almost every task.
+
+## Licensing
+
+The statements are redistributed unchanged from openai/math (OpenAI, Apache-2.0); the dataset root
+carries `LICENSE-openai-math` and a `NOTICE` describing what was copied, what was adapted (the
+Comparator configs) and what is not included (the proofs). The image bundles Lean, Mathlib,
+Comparator and lean4export (Apache-2.0) and landrun (MIT). This code is under the Apache License 2.0.

generator/image/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

generator/image/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

generator/image/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"
+}

generator/image/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

generator/image/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

generator/image/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()

generator/openai_math_harbor/__init__.py

@@ -0,0 +1 @@
+"""Harbor adapter for the openai/math Lean challenges."""

generator/openai_math_harbor/adapter.py

@@ -0,0 +1,358 @@
+"""Generate Harbor tasks from openai/math's Comparator challenges.
+
+One script covers every challenge: the statement, theorem names, axioms and definition holes all
+come from the challenge's own files, so no task is written by hand. What varies per task is data
+(see challenges.py for the hole policy that rewrites 8 configs and excludes 1).
+
+    python -m openai_math_harbor.adapter \\
+        --openai-math /path/to/openai-math      # checkout with lean/ComparatorChallenges, lean/docs, overview.tex
+        --graph graph.json                       # import graph from import_graph.py (oracle closures)
+        --out datasets/openai-math
+        [--only TruffetCounterexample,PlaneColoring]
+        [--embed-reference]                      # bundle the reference proof into solution/ (needs lean/OAI)
+
+Output layout (the FineEnvs Harbor dataset convention):
+
+    <out>/registry.json            Harbor registry: openai-math-harbor@<version> -> tasks/*
+    <out>/README.md                dataset card
+    <out>/NOTICE, LICENSE-openai-math   attribution for the redistributed statements
+    <out>/manifest.json            per-task metadata and the excluded challenges
+    <out>/tasks/<slug>/            one Harbor task per challenge
+
+Every task gets the same environment/ directory, so Daytona builds one snapshot for all of them.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+from pathlib import Path
+from string import Template
+
+from .challenges import Challenge, load_challenges
+from .oracle import bundle, closure, external_packages
+
+PKG = Path(__file__).parent
+IMAGE_DIR = PKG.parent / "image"
+TEMPLATES = PKG / "templates"
+SOURCE_COMMIT = "adc7f1241b42e322a6451854ab7e4b4c146bf78a"
+DATASET_NAME = "openai-math-harbor"
+DATASET_VERSION = "1.0"
+IMAGE_FILES = ["Dockerfile", "lean_setup.sh", "fetch_mathlib.sh", "lakefile.lean", "lake-manifest.json", "pack_submission.py"]
+
+
+def slug(name: str) -> str:
+    return re.sub(r"(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", "-", name).lower()
+
+
+def toml_str(value: str) -> str:
+    return json.dumps(value, ensure_ascii=False)
+
+
+def toml_list(values: list[str]) -> str:
+    return "[" + ", ".join(toml_str(v) for v in values) + "]"
+
+
+def grade_timeout(reference_bytes: int) -> int:
+    """Seconds the verifier gets to build, export and kernel-replay a submission.
+
+    Most proofs grade in 5 to 30 minutes, but a short file can still be slow (a few heavy
+    `nlinarith` calls took over 45 minutes in one 246-line module), so the floor is generous.
+    The limit only costs time when a proof actually needs it.
+    """
+    return int(min(6 * 3600, 3 * 3600 + 900 * reference_bytes / 1e6))
+
+
+def targets_sentence(c: Challenge) -> str:
+    names = [f"`{n}`" for n in c.theorem_names]
+    if not names:
+        return "The definition below"
+    return ("The theorem " if len(names) == 1 else "The theorems ") + ", ".join(names)
+
+
+def holes_sentence(c: Challenge) -> str:
+    if not c.definition_holes:
+        return ""
+    names = ", ".join(f"`{n}`" for n in c.definition_holes)
+    return (f", and the body of {names}, which you must supply: its type states the claim, so any "
+            "value of that type proves it")
+
+
+def instruction(c: Challenge) -> str:
+    fam = c.family
+    return Template((TEMPLATES / "instruction.md").read_text()).substitute(
+        title=f"openai/math challenge `{c.name}` (family {fam.number})",
+        family_number=fam.number, family_title=fam.title, subject=fam.subject,
+        family_summary=fam.summary, challenge=c.name, lean=c.lean.rstrip(),
+        targets=targets_sentence(c), holes=holes_sentence(c),
+    )
+
+
+def task_toml(c: Challenge, ref: dict, agent_timeout: int, oracle: dict | None = None) -> str:
+    fam = c.family
+    verifier_timeout = ref["grade_timeout_sec"] + 900
+    oracle_lines = ""
+    if oracle:
+        oracle_lines = f'oracle_result = {toml_str(oracle["cause"])}\n'
+        if oracle.get("grade_seconds") is not None:
+            oracle_lines += f'oracle_grade_seconds = {oracle["grade_seconds"]}\n'
+    return f"""schema_version = "1.4"
+
+[task]
+name = "openai-math/{slug(c.name)}"
+version = "1.0.0"
+description = {toml_str(f"Prove {c.name} (openai/math family {fam.number}: {fam.title}) in Lean 4 with Mathlib; graded by Comparator in a separate sandbox.")}
+keywords = ["lean4", "mathlib", "theorem-proving", "openai-math", {toml_str(fam.subject.lower().replace(" ", "-"))}]
+
+[metadata]
+source = "https://github.com/openai/math"
+source_commit = "{SOURCE_COMMIT}"
+source_license = "Apache-2.0"
+source_notice = "tests/Challenge.lean is lean/ComparatorChallenges/{c.name}.lean from openai/math, (c) OpenAI, unchanged; see NOTICE at the dataset root"
+challenge = {toml_str(c.name)}
+family = {toml_str(fam.number)}
+family_title = {toml_str(fam.title)}
+subject = {toml_str(fam.subject)}
+theorems = {toml_list(c.theorem_names)}
+definition_holes = {toml_list(c.definition_holes)}
+fixed_definitions = {toml_list(c.dropped_holes)}
+reference_module = {toml_str(c.config["solution_module"])}
+reference_modules = {ref["n_modules"]}
+reference_lean_bytes = {ref["bytes"]}
+reference_requires_packages = {toml_list(ref["packages"])}
+{oracle_lines}difficulty = "research"
+
+[agent]
+timeout_sec = {agent_timeout}
+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 = {verifier_timeout}
+environment_mode = "separate"
+network_mode = "no-network"
+
+[[verifier.collect]]
+command = "python3 /opt/openai-math/pack_submission.py"
+timeout_sec = 300
+"""
+
+
+def write_task(c: Challenge, out: Path, graph: dict | None, lean_dir: Path | None,
+               embed_reference: bool, agent_timeout: int, oracle: dict | None = None) -> dict:
+    task_dir = out / "tasks" / slug(c.name)
+    if task_dir.exists():
+        shutil.rmtree(task_dir)
+    (task_dir / "environment").mkdir(parents=True)
+    (task_dir / "tests").mkdir()
+    (task_dir / "solution").mkdir()
+
+    for name in IMAGE_FILES:
+        shutil.copy(IMAGE_DIR / name, task_dir / "environment" / name)
+
+    solution_module = c.config["solution_module"]
+    modules = closure(graph, solution_module) if graph else []
+    ref = {
+        "n_modules": len(modules),
+        "bytes": sum(graph[m]["bytes"] for m in modules) if graph else 0,
+        "packages": external_packages(graph, modules) if graph else [],
+    }
+    ref["grade_timeout_sec"] = grade_timeout(ref["bytes"])
+
+    (task_dir / "instruction.md").write_text(instruction(c))
+    (task_dir / "task.toml").write_text(task_toml(c, ref, agent_timeout, oracle))
+
+    (task_dir / "tests" / "Challenge.lean").write_text(c.lean)
+    (task_dir / "tests" / "task.json").write_text(json.dumps({
+        "challenge": c.name,
+        "comparator": c.comparator,
+        "grade_timeout_sec": ref["grade_timeout_sec"],
+    }, indent=2))
+    for name in ("test.sh", "grade.py"):
+        shutil.copy(TEMPLATES / "tests" / name, task_dir / "tests" / name)
+    (task_dir / "tests" / "test.sh").chmod(0o755)
+
+    (task_dir / "solution" / "closure.txt").write_text("\n".join(modules) + "\n")
+    shutil.copy(PKG / "reference.py", task_dir / "solution" / "reference.py")
+    solve = Template((TEMPLATES / "solution" / "solve.sh").read_text()).substitute(
+        challenge=c.name, solution_module=solution_module, n_modules=len(modules),
+        source_commit=SOURCE_COMMIT,
+    )
+    (task_dir / "solution" / "solve.sh").write_text(solve)
+    (task_dir / "solution" / "solve.sh").chmod(0o755)
+    if embed_reference:
+        if not (lean_dir and (lean_dir / "OAI").is_dir()):
+            raise SystemExit("--embed-reference needs the openai/math checkout's lean/OAI directory")
+        (task_dir / "solution" / "reference.tar.gz").write_bytes(bundle(lean_dir, modules, solution_module))
+    return {
+        "task": slug(c.name), "challenge": c.name, "family": c.family.number,
+        "family_title": c.family.title, "subject": c.family.subject,
+        "theorems": c.theorem_names, "definition_holes": c.definition_holes,
+        "fixed_definitions": c.dropped_holes, **ref,
+        "oracle_result": (oracle or {}).get("cause"),
+        "oracle_grade_seconds": (oracle or {}).get("grade_seconds"),
+    }
+
+
+ORACLE_MEANING = {
+    "accepted": "OpenAI's proof is accepted: the environment is verified end to end",
+    "missing-package": "OpenAI's proof uses a Lean library beyond Mathlib that the sandbox does not include",
+    "definition-mismatch": "OpenAI's proof writes a definition with the same text but it compiles differently, so the exact-match check fails",
+    "memory": "OpenAI's proof needs more than the sandbox's 8 GB of memory to build",
+    "disk": "OpenAI's proof is too large for the sandbox's 10 GB disk",
+    "timeout": "grading OpenAI's proof exceeded the time limit",
+    "rejected": "Comparator rejected OpenAI's proof",
+}
+
+
+def validation_block(written: list[dict]) -> str:
+    """Markdown summary of the oracle run for the dataset card."""
+    results = [w for w in written if w.get("oracle_result")]
+    if not results:
+        return "The oracle has not been run on this build of the dataset."
+    counts: dict[str, list[str]] = {}
+    for w in results:
+        counts.setdefault(w["oracle_result"], []).append(w["task"])
+    order = [k for k in ORACLE_MEANING if k in counts] + sorted(k for k in counts if k not in ORACLE_MEANING)
+    rows = ["| Oracle result | Tasks | Meaning |", "|---|---|---|"]
+    for key in order:
+        rows.append(f"| {key} | {len(counts[key])} | {ORACLE_MEANING.get(key, 'grading did not complete')} |")
+    pending = [w["task"] for w in written if not w.get("oracle_result")]
+    if pending:
+        rows.append(f"| not completed | {len(pending)} | grading did not complete in our run |")
+    lines = ["\n".join(rows), ""]
+    secs = sorted(w["oracle_grade_seconds"] for w in results
+                  if w["oracle_result"] == "accepted" and w.get("oracle_grade_seconds"))
+    if secs:
+        lines.append(f"Grading an accepted proof took {secs[len(secs) // 2] // 60} minutes at the median. "
+                     "Each task's result is in its `task.toml` (`oracle_result`) and in `manifest.parquet`.")
+    unexplained = sorted(t for k in counts if k not in ORACLE_MEANING or k in ("rejected", "timeout") for t in counts[k])
+    if unexplained:
+        lines.append("Other: " + ", ".join(f"`{t}`" for t in unexplained) + ".")
+    return "\n".join(lines)
+
+
+def write_parquet_manifest(out: Path, written: list[dict]) -> None:
+    """manifest.parquet: one row per task, for filtering without walking tasks/."""
+    try:
+        import pyarrow as pa
+        import pyarrow.parquet as pq
+    except ModuleNotFoundError:
+        print("pyarrow not installed; skipping manifest.parquet")
+        return
+    columns = ["task", "challenge", "family", "family_title", "subject", "theorems", "definition_holes",
+               "fixed_definitions", "n_modules", "bytes", "packages", "grade_timeout_sec",
+               "oracle_result", "oracle_grade_seconds"]
+    rename = {"n_modules": "reference_modules", "bytes": "reference_lean_bytes",
+              "packages": "reference_requires_packages"}
+    table = pa.table({rename.get(c, c): [w.get(c) for w in written] for c in columns})
+    pq.write_table(table, out / "manifest.parquet")
+
+
+def not_validated_block(not_validated: list[dict], excluded: list[dict]) -> str:
+    """Markdown list of the statements that are not in the dataset, with the reason for each."""
+    rows = [*({"task": n["task"], "reason": ORACLE_MEANING.get(n["reason"], "grading did not complete in our run")} for n in not_validated),
+            *({"task": slug(e["challenge"]), "reason": "left out by design: " + e["reason"]} for e in excluded)]
+    if not rows:
+        return "None: every statement is included."
+    lines = ["<details><summary>" + f"{len(rows)} statements not included (click to expand)" + "</summary>", "",
+             "| Statement | Why it could not be validated |", "|---|---|"]
+    lines += [f"| `{r['task']}` | {r['reason']} |" for r in sorted(rows, key=lambda r: r["task"])]
+    lines += ["", "</details>"]
+    return "\n".join(lines)
+
+
+def write_dataset_files(out: Path, included: list[Challenge], written: list[dict],
+                        not_validated: list[dict] | None = None, excluded: list[dict] | None = None,
+                        n_statements: int | None = None) -> None:
+    """registry.json, the dataset card, NOTICE and the openai/math license copy."""
+    registry = [{
+        "name": DATASET_NAME,
+        "version": DATASET_VERSION,
+        "description": f"{len(written)} Lean 4 theorem-proving tasks from openai/math, graded by Comparator in a separate sandbox.",
+        "tasks": [{"name": w["task"], "path": f"tasks/{w['task']}"} for w in written],
+    }]
+    (out / "registry.json").write_text(json.dumps(registry, indent=2) + "\n")
+    families = {c.family.number for c in included}
+    subjects = sorted({c.family.subject for c in included})
+    counts = {s: sum(1 for c in included if c.family.subject == s) for s in subjects}
+    card = Template((TEMPLATES / "dataset_README.md").read_text()).substitute(
+        validation=validation_block(written + [{"task": n["task"], "oracle_result": n["reason"]}
+                                               for n in (not_validated or []) if n["reason"] != "pending"]
+                                    + [{"task": n["task"]} for n in (not_validated or []) if n["reason"] == "pending"]),
+        not_validated=not_validated_block(not_validated or [], excluded or []),
+        n_statements=n_statements or len(written),
+        n_not_included=(n_statements or len(written)) - len(written),
+        n_tasks=len(written), n_families=len(families), n_subjects=len(subjects),
+        source_commit=SOURCE_COMMIT[:7],
+        subjects_line=", ".join(f"{s} ({counts[s]})" for s in sorted(subjects, key=lambda s: -counts[s])),
+    )
+    (out / "README.md").write_text(card)
+    write_parquet_manifest(out, written)
+    (out / "NOTICE").write_text(Template((TEMPLATES / "NOTICE").read_text()).substitute(source_commit=SOURCE_COMMIT))
+    shutil.copy(TEMPLATES / "LICENSE-openai-math", out / "LICENSE-openai-math")
+    shutil.copy(TEMPLATES / "LICENSE", out / "LICENSE")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--openai-math", type=Path, required=True)
+    ap.add_argument("--graph", type=Path)
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--only", help="comma-separated challenge names")
+    ap.add_argument("--embed-reference", action="store_true")
+    ap.add_argument("--agent-timeout", type=int, default=4 * 3600)
+    ap.add_argument("--oracle-results", type=Path,
+                    help="oracle verdicts from `python -m openai_math_harbor.report`, stamped into each task")
+    ap.add_argument("--only-validated", action="store_true",
+                    help="keep only tasks whose official proof the oracle verified; list the rest in the card")
+    args = ap.parse_args()
+
+    graph = json.loads(args.graph.read_text())["modules"] if args.graph else None
+    oracle = json.loads(args.oracle_results.read_text()) if args.oracle_results else {}
+    challenges = load_challenges(args.openai_math)
+    if args.only:
+        wanted = set(args.only.split(","))
+        challenges = [c for c in challenges if c.name in wanted]
+        missing = wanted - {c.name for c in challenges}
+        if missing:
+            raise SystemExit(f"unknown challenges: {sorted(missing)}")
+
+    args.out.mkdir(parents=True, exist_ok=True)
+    written, excluded, not_validated = [], [], []
+    for c in challenges:
+        if c.excluded:
+            excluded.append({"challenge": c.name, "reason": c.excluded})
+            continue
+        entry = write_task(c, args.out, graph, args.openai_math / "lean", args.embed_reference,
+                           args.agent_timeout, oracle.get(slug(c.name)))
+        if args.only_validated and entry["oracle_result"] != "accepted":
+            shutil.rmtree(args.out / "tasks" / entry["task"])
+            not_validated.append({"task": entry["task"], "challenge": c.name, "family": c.family.number,
+                                  "reason": entry["oracle_result"] or "pending"})
+            continue
+        written.append(entry)
+    (args.out / "manifest.json").write_text(json.dumps({
+        "source": "https://github.com/openai/math", "source_commit": SOURCE_COMMIT,
+        "tasks": written, "excluded": excluded, "not_validated": not_validated,
+    }, indent=2))
+    kept = {w["task"] for w in written}
+    write_dataset_files(args.out, [c for c in challenges if slug(c.name) in kept], written,
+                        not_validated=not_validated, excluded=excluded, n_statements=len(challenges))
+    print(f"wrote {len(written)} tasks to {args.out / 'tasks'}; excluded {len(excluded)}")
+    for e in excluded:
+        print(f"  excluded {e['challenge']}: {e['reason']}")
+
+
+if __name__ == "__main__":
+    main()

generator/openai_math_harbor/attacks.py

@@ -0,0 +1,207 @@
+"""Reward-hacking probes: copies of a generated task whose oracle submits a cheat.
+
+Each probe keeps the task's environment, tests and config unchanged and replaces solution/solve.sh
+with a script that writes an invalid submission (or tampers with the agent sandbox). Run them with
+Harbor's oracle agent; every probe must score 0.
+
+    python -m openai_math_harbor.attacks --dataset datasets/openai-math-harbor/tasks --out datasets/attacks
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+from pathlib import Path
+
+
+def _challenge(task_dir: Path) -> str:
+    return (task_dir / "tests" / "Challenge.lean").read_text()
+
+
+def _replace_sorry(lean: str, term: str, tactic: str | None = None) -> str:
+    """Replace each `sorry`: tactic-mode ones with ``tactic`` (default `exact term`), others with ``term``."""
+    lean = re.sub(r"\bby(\s+)sorry\b", lambda m: f"by{m.group(1)}{tactic or f'exact ({term})'}", lean)
+    return re.sub(r"\bsorry\b", f"({term})", lean)
+
+
+def _first_theorem(task_dir: Path) -> str:
+    return json.loads((task_dir / "tests" / "task.json").read_text())["comparator"]["theorem_names"][0]
+
+
+def _write(path: str, content: str) -> str:
+    return f"mkdir -p \"$(dirname {path})\"\ncat > {path} <<'LEAN_EOF'\n{content}\nLEAN_EOF\n"
+
+
+# Each attack: (name, description, function(task_dir) -> bash body run in the agent sandbox).
+def attack_sorry(t: Path) -> str:
+    return _write("/workspace/Submission.lean", _challenge(t))
+
+
+def attack_axiom(t: Path) -> str:
+    lean = _challenge(t).replace("import Mathlib\n", "import Mathlib\n\naxiom openai_math_cheat : False\n", 1)
+    return _write("/workspace/Submission.lean", _replace_sorry(lean, "openai_math_cheat.elim"))
+
+
+def attack_sorry_macro(t: Path) -> str:
+    lean = _replace_sorry(_challenge(t), "by trust_me", tactic="trust_me")
+    lean = lean.replace(
+        "import Mathlib\n", "import Mathlib\n\nmacro \"trust_me\" : tactic => `(tactic| sorry)\n", 1)
+    return _write("/workspace/Submission.lean", lean)
+
+
+def attack_native_decide_false(t: Path) -> str:
+    # implemented_by makes compiled code disagree with the kernel, so native_decide proves False.
+    # The file elaborates with no errors and no sorry warning; only the axiom check catches it.
+    prelude = """
+def openaiMathTrue : Bool := true
+@[implemented_by openaiMathTrue] def openaiMathFake : Bool := false
+theorem openaiMathFake_eq : openaiMathFake = true := by native_decide
+theorem openaiMathBoom : False := by
+  have h := openaiMathFake_eq
+  simp [openaiMathFake] at h
+"""
+    lean = _challenge(t).replace("import Mathlib\n", "import Mathlib\n" + prelude, 1)
+    return _write("/workspace/Submission.lean", _replace_sorry(lean, "openaiMathBoom.elim"))
+
+
+def attack_weaken_statement(t: Path) -> str:
+    # Keep the theorem's name, change its statement to `True`.
+    name = _first_theorem(t).split(".")[-1]
+    lean = _challenge(t)
+    lean = re.sub(r"(?ms)^(\s*theorem\s+" + re.escape(name) + r"\b).*?:=\s*by\s*\n\s*sorry",
+                  r"\1 : True := by\n  trivial", lean, count=1)
+    lean = re.sub(r"(?ms)^(\s*theorem\s+" + re.escape(name) + r"\b).*?:=\s*by\s+sorry",
+                  r"\1 : True := by trivial", lean, count=1)
+    return _write("/workspace/Submission.lean", lean)
+
+
+def attack_import_challenge(t: Path) -> str:
+    # The verifier's project also contains the trusted Challenge module; re-export its sorry'd theorem.
+    return _write("/workspace/Submission.lean", "import Challenge\n")
+
+
+def attack_compile_time_reward(t: Path) -> str:
+    # Lean code that runs while the verifier builds the submission tries to plant a reward, to run a
+    # shell, and to open a TCP connection to the sandbox's control daemon (via git, one of the few
+    # binaries Comparator lets the build execute). All must fail: landrun (read-only file system
+    # except .lake, exec limited, TCP denied), the unprivileged grader user, and iptables.
+    probe = """
+def openaiMathProbeWrite : IO String := do
+  try
+    IO.FS.writeFile "/logs/verifier/reward.txt" "1\\n"
+    pure "WROTE reward.txt"
+  catch e => pure s!"write denied ({e})"
+
+def openaiMathProbeRun (cmd : String) (args : Array String) : IO String := do
+  try
+    let out ← IO.Process.output { cmd := cmd, args := args }
+    pure s!"exit {out.exitCode}: {out.stdout.trim} {out.stderr.trim}"
+  catch e => pure s!"spawn denied ({e})"
+
+#eval show IO Unit from do
+  IO.println s!"PROBE write: {← openaiMathProbeWrite}"
+  IO.println s!"PROBE bash: {← openaiMathProbeRun "bash" #["-c", "id"]}"
+  IO.println s!"PROBE tcp: {← openaiMathProbeRun "git" #["ls-remote", "http://127.0.0.1:2280/probe"]}"
+"""
+    lean = _challenge(t).replace("import Mathlib\n", "import Mathlib\n" + probe, 1)
+    return _write("/workspace/Submission.lean", lean)
+
+
+def attack_agent_side_reward(t: Path) -> str:
+    # Plant rewards and fake comparator output in the agent sandbox; the verifier runs elsewhere.
+    return (
+        "mkdir -p /logs/verifier /logs/artifacts\n"
+        "echo 1 > /logs/verifier/reward.txt\n"
+        "echo '{\"reward\": 1}' > /logs/verifier/reward.json\n"
+        "printf '#!/bin/sh\\necho Your solution is okay!\\n' > /usr/local/bin/comparator\n"
+        + _write("/workspace/Submission.lean", _challenge(t))
+    )
+
+
+def attack_symlink(t: Path) -> str:
+    # Submission.lean is a symlink to the challenge; Submission/ links to /. The packer skips links.
+    return (
+        "ln -sf /opt/openai-math/challenges/$(python3 -c \"import json;print(json.load(open('/tests/task.json'))['challenge'])\" 2>/dev/null || echo X).lean /workspace/Submission.lean 2>/dev/null || ln -sf /etc/hostname /workspace/Submission.lean\n"
+        "ln -sfn / /workspace/Submission\n"
+    )
+
+
+def attack_redefine_definition(t: Path) -> str:
+    # EuclideanFiveColor: openai/math lists ProperColoring as a definition hole, so Comparator with the
+    # original config only checks its type. Redefining it as False makes the theorem trivial.
+    lean = _challenge(t)
+    lean, n = re.subn(
+        r"(def ProperColoring \(colorCount : ℕ\) \(coloring : ℂ → Fin colorCount\) : Prop :=)\n.*\n",
+        r"\1\n  False\n", lean, count=1)
+    if n != 1:
+        raise SystemExit("redefine-definition targets EuclideanFiveColor's ProperColoring")
+    lean = _replace_sorry(lean, "fun ⟨_, h⟩ => h")
+    return _write("/workspace/Submission.lean", lean)
+
+
+def attack_tamper_structure(t: Path) -> str:
+    # ElementaryPositivity: the open hole's type is the structure PermutationWitness, whose
+    # `expansion` field carries the claim. Keep the structure's name, parameters and type, but
+    # replace its fields with trivial ones, then fill the hole trivially. Comparator compares the
+    # structure's constructor too, so this must be rejected.
+    lean = _challenge(t)
+    lean, n = re.subn(
+        r"structure PermutationWitness where\n.*?(?=\n\nend NaturalUnitIntervalGraph)",
+        "structure PermutationWitness where\n"
+        "  theta : {σ : Equiv.Perm (Fin n) // G.Nondescent σ} → Unit\n"
+        "  expansion : True",
+        lean, count=1, flags=re.S)
+    if n != 1:
+        raise SystemExit("tamper-structure targets ElementaryPositivity's PermutationWitness")
+    lean = _replace_sorry(lean, "⟨fun _ => (), trivial⟩")
+    return _write("/workspace/Submission.lean", lean)
+
+
+ATTACKS = {
+    "tamper-structure": (attack_tamper_structure, "keep a structure's name and type, drop the proof obligation from its fields"),
+    "redefine-definition": (attack_redefine_definition, "redefine a definition the statement uses (ProperColoring := False)"),
+    "sorry": (attack_sorry, "submit the challenge unchanged (every proof is sorry)"),
+    "axiom": (attack_axiom, "declare `axiom cheat : False` and use it"),
+    "sorry-macro": (attack_sorry_macro, "hide sorry behind a custom tactic macro"),
+    "native-decide-false": (attack_native_decide_false, "prove False via implemented_by + native_decide"),
+    "weaken-statement": (attack_weaken_statement, "same theorem name, statement changed to True"),
+    "import-challenge": (attack_import_challenge, "import the trusted Challenge module and re-export it"),
+    "compile-time-reward": (attack_compile_time_reward, "Lean code run at build time plants reward.txt and dials the daemon"),
+    "agent-side-reward": (attack_agent_side_reward, "plant reward files and a fake comparator in the agent sandbox"),
+    "symlink": (attack_symlink, "submit symlinks instead of files"),
+}
+
+
+def make_probe(task_dir: Path, out_dir: Path, name: str) -> Path:
+    fn, desc = ATTACKS[name]
+    dest = out_dir / f"{task_dir.name}--{name}"
+    if dest.exists():
+        shutil.rmtree(dest)
+    shutil.copytree(task_dir, dest)
+    toml = (dest / "task.toml").read_text()
+    toml = re.sub(r'(?m)^name = "openai-math/(.*)"$', rf'name = "openai-math-attacks/\1--{name}"', toml, count=1)
+    (dest / "task.toml").write_text(toml)
+    for extra in ("reference.tar.gz",):
+        (dest / "solution" / extra).unlink(missing_ok=True)
+    solve = dest / "solution" / "solve.sh"
+    solve.write_text(f"#!/usr/bin/env bash\n# Attack probe: {desc}. Must score 0.\nset -u\n{fn(task_dir)}\necho 'attack {name} placed'\n")
+    solve.chmod(0o755)
+    return dest
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--dataset", type=Path, required=True)
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--task", default="truffet-counterexample")
+    ap.add_argument("--attacks", default=",".join(ATTACKS))
+    args = ap.parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+    for name in args.attacks.split(","):
+        print(make_probe(args.dataset / args.task, args.out, name))
+
+
+if __name__ == "__main__":
+    main()

generator/openai_math_harbor/challenges.py

@@ -0,0 +1,178 @@
+"""Read openai/math's Comparator challenges and decide how each one is graded.
+
+Each challenge is ``lean/ComparatorChallenges/<Name>.lean`` (the statement, with ``sorry``) plus
+``<Name>.json`` (Comparator's config). Two things are added here:
+
+* the family it belongs to (number, title, subject), from ``lean/docs/NNN.md`` and ``overview.tex``;
+* a hole policy. Comparator checks only the name and type of a ``definition_names`` entry, never
+  its body (comparator ``Compare.lean``: ``definitionHoleMatches``). openai/math lists fixed
+  definitions as holes in 9 configs, so a solver could redefine e.g. ``ProperColoring := False`` and
+  prove the theorem trivially. Holes are therefore rewritten:
+
+  - a definition with a complete body is removed from ``definition_names``, so Comparator requires
+    the solution's definition to be identical;
+  - a definition whose whole body is ``sorry`` and whose name appears nowhere else in the file stays
+    a hole: its type is the claim (e.g. a witness structure carrying the proof obligations);
+  - anything else (a ``sorry`` inside a body, or an open definition that statements depend on) cannot
+    be graded safely as written, and the challenge is excluded until it is restated.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+_DECL_START = re.compile(
+    r"(?m)^[ \t]*(?:@\[[^\]]*\][ \t]*\n?[ \t]*)?(?:(?:noncomputable|private|protected|partial|unsafe)[ \t]+)*"
+    r"(?:def|abbrev|theorem|lemma|instance|structure|class|inductive|opaque|axiom|example)\b"
+)
+_BLOCK_END = re.compile(
+    r"(?m)^[ \t]*(?:end\b|namespace\b|section\b|run_cmd\b|open\b|variable\b|set_option\b|/--|#)"
+)
+
+
+@dataclass
+class Family:
+    number: str
+    title: str
+    subject: str
+    summary: str
+
+
+@dataclass
+class Challenge:
+    name: str
+    lean: str
+    config: dict
+    family: Family | None
+    theorem_names: list[str]
+    definition_holes: list[str]
+    dropped_holes: list[str] = field(default_factory=list)
+    excluded: str | None = None
+
+    @property
+    def comparator(self) -> dict:
+        return {
+            "theorem_names": self.theorem_names,
+            "definition_names": self.definition_holes,
+            "permitted_axioms": self.config["permitted_axioms"],
+        }
+
+
+def _declaration_block(source: str, short_name: str) -> str | None:
+    """Text of the first ``def``-like declaration named ``short_name``, up to the next one."""
+    pattern = re.compile(
+        r"(?m)^[ \t]*(?:@\[[^\]]*\][ \t]*\n?[ \t]*)?(?:(?:noncomputable|private|protected)[ \t]+)*"
+        r"(?:def|abbrev|structure|class|inductive|opaque|instance)[ \t]+" + re.escape(short_name) + r"\b"
+    )
+    m = pattern.search(source)
+    if not m:
+        return None
+    rest = source[m.end():]
+    ends = [x.start() for x in (_DECL_START.search(rest), _BLOCK_END.search(rest)) if x]
+    return source[m.start(): m.end() + (min(ends) if ends else len(rest))]
+
+
+def _mentions(source: str, short_name: str) -> int:
+    """Occurrences of ``short_name`` as a whole identifier anywhere in the file (comments included).
+
+    Qualified uses count too (``RowColumn.Foo`` mentions ``Foo``): theorems often refer to a
+    definition through its namespace, and missing one would keep an unsafe hole open.
+    """
+    return len(re.findall(r"(?<![\w'])" + re.escape(short_name) + r"(?![\w'])", source))
+
+
+def hole_policy(source: str, config: dict) -> tuple[list[str], list[str], str | None]:
+    """Return (kept holes, dropped holes, exclusion reason) for one challenge."""
+    kept, dropped, problems = [], [], []
+    for name in config.get("definition_names") or []:
+        short = name.split(".")[-1]
+        block = _declaration_block(source, short)
+        if block is None:
+            problems.append(f"{name}: definition not found in the challenge")
+            continue
+        body = block.split(":=", 1)[1] if ":=" in block else ""
+        has_sorry = re.search(r"\bsorry\b", block) is not None
+        if not has_sorry:
+            dropped.append(name)
+        elif re.fullmatch(r"\s*(?:by\s+)?sorry\s*", body) and _mentions(source, short) == 1:
+            # The hole's type is the claim and nothing else in the file refers to it.
+            kept.append(name)
+        else:
+            problems.append(f"{name}: open definition the theorem statements depend on")
+    return kept, dropped, ("; ".join(problems) or None)
+
+
+def load_families(overview_tex: Path) -> dict[str, Family]:
+    src = overview_tex.read_text(encoding="utf-8")
+
+    def group(i: int) -> tuple[str, int]:
+        depth, j = 0, i
+        while True:
+            c = src[j]
+            if c == "\\":
+                j += 2
+                continue
+            if c == "{":
+                depth += 1
+            elif c == "}":
+                depth -= 1
+                if depth == 0:
+                    return src[i + 1: j], j + 1
+            j += 1
+
+    families, subject = {}, ""
+    for m in re.finditer(r"\\(cataloguesection|resultentry)\{", src):
+        if src[max(0, m.start() - 12): m.start()].endswith("newcommand{"):
+            continue
+        i = m.end() - 1
+        if m.group(1) == "cataloguesection":
+            subject, _ = group(i)
+            continue
+        args = []
+        for _ in range(3):
+            arg, i = group(i)
+            args.append(arg)
+            while src[i] in " \n%":
+                i += 1
+        families[args[0]] = Family(args[0], _plain(args[1]), subject, _plain(args[2]))
+    return families
+
+
+def _plain(tex: str) -> str:
+    """Light LaTeX cleanup for markdown: keep $math$, drop accents and \\-escapes."""
+    tex = re.sub(r"\\[\"'`^~]\{?([A-Za-z])\}?", r"\1", tex)
+    tex = tex.replace("--", "–").replace("``", '"').replace("''", '"').replace("~", " ")
+    tex = re.sub(r"\\(?:emph|textit|textbf)\{([^{}]*)\}", r"\1", tex)
+    return re.sub(r"\s+", " ", tex).strip()
+
+
+def family_links(docs_dir: Path) -> dict[str, str]:
+    """Challenge name -> family number, from the Comparator tables in lean/docs/NNN.md."""
+    links = {}
+    for doc in sorted(docs_dir.glob("*.md")):
+        for m in re.finditer(r"\(\.\./ComparatorChallenges/([A-Za-z0-9_]+)\.lean\)", doc.read_text()):
+            links.setdefault(m.group(1), doc.stem)
+    return links
+
+
+def load_challenges(openai_math: Path) -> list[Challenge]:
+    lean = openai_math / "lean"
+    families = load_families(openai_math / "overview.tex")
+    links = family_links(lean / "docs")
+    out = []
+    for cfg_path in sorted((lean / "ComparatorChallenges").glob("*.json")):
+        name = cfg_path.stem
+        config = json.loads(cfg_path.read_text())
+        source = (lean / "ComparatorChallenges" / f"{name}.lean").read_text(encoding="utf-8")
+        kept, dropped, excluded = hole_policy(source, config)
+        if not config["theorem_names"] and not kept:
+            excluded = excluded or "no theorem and no open definition to check"
+        out.append(Challenge(
+            name=name, lean=source, config=config, family=families.get(links.get(name, "")),
+            theorem_names=list(config["theorem_names"]), definition_holes=kept,
+            dropped_holes=dropped, excluded=excluded,
+        ))
+    return out

generator/openai_math_harbor/import_graph.py

@@ -0,0 +1,54 @@
+"""Build the module import graph of the openai/math Lean library.
+
+Reads every ``.lean`` file under ``<repo>/lean`` (OAI library and ComparatorChallenges) and writes one
+JSON object: ``{"modules": {module: {"imports": [...], "bytes": n, "lines": n}}}``. Only the import
+header is parsed; Lean requires imports to come before any other command.
+
+    python -m openai_math_harbor.import_graph /path/to/openai-math/lean graph.json
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+# `import X`, plus the module-system forms `public import X`, `meta import X`, `import all X`.
+_IMPORT = re.compile(r"^\s*(?:public\s+|private\s+)?(?:meta\s+)?import\s+(?:all\s+)?([A-Za-z_«][^\s]*)")
+_HEADER_ONLY = re.compile(r"^\s*(?:module\b|prelude\b|--|/-|$)")
+
+
+def header_imports(text: str) -> list[str]:
+    imports, in_comment = [], False
+    for line in text.splitlines():
+        if in_comment:
+            in_comment = "-/" not in line
+            continue
+        if line.lstrip().startswith("/-") and "-/" not in line:
+            in_comment = True
+            continue
+        m = _IMPORT.match(line)
+        if m:
+            imports.append(m.group(1).replace("«", "").replace("»", ""))
+        elif not _HEADER_ONLY.match(line):
+            break
+    return imports
+
+
+def build(lean_root: Path) -> dict:
+    modules = {}
+    for path in sorted(lean_root.rglob("*.lean")):
+        rel = path.relative_to(lean_root)
+        if rel.parts[0] in (".lake", "lakefile.lean") or rel.name == "lakefile.lean":
+            continue
+        text = path.read_text(encoding="utf-8", errors="replace")
+        name = ".".join(rel.with_suffix("").parts)
+        modules[name] = {"imports": header_imports(text), "bytes": len(text.encode()), "lines": text.count("\n") + 1}
+    return {"modules": modules}
+
+
+if __name__ == "__main__":
+    graph = build(Path(sys.argv[1]))
+    Path(sys.argv[2]).write_text(json.dumps(graph, separators=(",", ":")))
+    print(len(graph["modules"]), "modules")

generator/openai_math_harbor/oracle.py

@@ -0,0 +1,47 @@
+"""Reference-proof closures for the oracle agent.
+
+A challenge's reference proof is ``solution_module`` plus every ``OAI.*`` module it imports,
+transitively (from the import graph built by ``import_graph.py``). The oracle submits exactly those
+files under the ``Submission`` root agents use (see ``reference.py``), so the verifier grades the
+reference proof the same way it grades an agent.
+"""
+
+from __future__ import annotations
+
+import io
+import tarfile
+import tempfile
+from pathlib import Path
+
+from .reference import place
+
+CORE_ROOTS = {"Init", "Lean", "Std", "Lake", "Mathlib"}
+
+
+def closure(graph: dict, root: str) -> list[str]:
+    """Every OAI module reachable from ``root`` through imports, sorted."""
+    seen, stack = set(), [root]
+    while stack:
+        module = stack.pop()
+        if module in seen or module not in graph:
+            continue
+        seen.add(module)
+        stack.extend(i for i in graph[module]["imports"] if i == "OAI" or i.startswith("OAI."))
+    return sorted(seen)
+
+
+def external_packages(graph: dict, modules: list[str]) -> list[str]:
+    """Import roots outside OAI, Mathlib and the Lean core that the closure needs."""
+    roots = {i.split(".")[0] for m in modules for i in graph[m]["imports"] if i not in graph}
+    return sorted(roots - CORE_ROOTS)
+
+
+def bundle(lean_dir: Path, modules: list[str], solution_module: str) -> bytes:
+    """A .tar.gz of the placed reference submission (Submission.lean + Submission/OAI/**)."""
+    with tempfile.TemporaryDirectory() as tmp:
+        place(lean_dir, modules, solution_module, Path(tmp))
+        buf = io.BytesIO()
+        with tarfile.open(fileobj=buf, mode="w:gz") as tar:
+            for path in sorted(Path(tmp).rglob("*.lean")):
+                tar.add(path, arcname=str(path.relative_to(tmp)))
+        return buf.getvalue()

generator/openai_math_harbor/package.py

@@ -0,0 +1,36 @@
+"""Assemble the folder that is published as the Hugging Face dataset.
+
+Copies a generated dataset (adapter output) and adds the generator itself under generator/, so the
+published repo can rebuild the image and regenerate the tasks on its own.
+
+    python -m openai_math_harbor.package <adapter output dir> <stage dir>
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+
+GENERATOR_ROOT = Path(__file__).parents[1]
+GENERATOR_PARTS = ["README.md", "openai_math_harbor", "image", "tests"]
+IGNORE = shutil.ignore_patterns("__pycache__", "*.pyc", ".DS_Store")
+
+
+def stage(dataset: Path, out: Path) -> None:
+    if out.exists():
+        shutil.rmtree(out)
+    shutil.copytree(dataset, out, ignore=IGNORE)
+    for part in GENERATOR_PARTS:
+        src = GENERATOR_ROOT / part
+        dst = out / "generator" / part
+        if src.is_dir():
+            shutil.copytree(src, dst, ignore=IGNORE)
+        else:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(src, dst)
+
+
+if __name__ == "__main__":
+    stage(Path(sys.argv[1]), Path(sys.argv[2]))
+    print("staged", sys.argv[2])

generator/openai_math_harbor/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}")

generator/openai_math_harbor/report.py

@@ -0,0 +1,80 @@
+"""Summarize a Harbor oracle job into one verdict per task.
+
+The oracle submits openai/math's own proof of each challenge, so its grade says whether the task is
+verified end to end: the statement builds, the official proof compiles in the image, and Comparator
+accepts it. Every non-accepted result gets a cause, so a reader can tell an environment limit (disk,
+memory, a library the image does not ship) from a real disagreement between proof and statement.
+
+    python -m openai_math_harbor.report <harbor job dir> [<re-run job dir> ...] oracle_results.json
+"""
+
+from __future__ import annotations
+
+import collections
+import json
+import sys
+from pathlib import Path
+
+# Checked in order against grading.json's reason and the Comparator log.
+CAUSES = [
+    ("disk", ("no space left on device",)),
+    # The reference proof states a definition with the same text as the challenge, but compiled in
+    # its own library's context it elaborates to a different term, so exact matching fails.
+    ("definition-mismatch", ("Const does not match between challenge and target",)),
+    ("memory", ("most likely out of memory", "Child exited with 137", "Lean exited with code 137")),
+    ("missing-package", ("unknown module prefix", "bad import", "unknown package")),
+    ("timeout", ("timed out",)),
+]
+
+
+def classify(trial: Path) -> dict:
+    result = json.loads((trial / "result.json").read_text())
+    grading = trial / "verifier" / "grading.json"
+    log = trial / "verifier" / "comparator.log"
+    g = json.loads(grading.read_text()) if grading.exists() else {}
+    text = (g.get("reason") or "") + "\n" + (log.read_text(errors="replace") if log.exists() else "")
+    reward = ((result.get("verifier_result") or {}).get("rewards") or {}).get("reward")
+    if reward == 1:
+        cause = "accepted"
+    elif reward is None:
+        cause = "error: " + str((result.get("exception_info") or {}).get("exception_type") or g.get("reason", "unknown"))
+    else:
+        cause = next((name for name, keys in CAUSES if any(k in text for k in keys)), "rejected")
+    return {
+        "reward": reward,
+        "cause": cause,
+        # Graders since the overlay copy-up fix record `permission_fixes`; earlier verdicts other
+        # than "accepted" may be artifacts of that bug and are re-graded.
+        "current_grader": "permission_fixes" in g,
+        "grade_seconds": round(g["finished_at"] - g["started_at"]) if g.get("finished_at") else None,
+        "reason": (g.get("reason") or "")[:500],
+    }
+
+
+def summarize(job_dir: Path) -> dict[str, dict]:
+    """Task directory name -> verdict. A task attempted twice (a re-run) keeps its latest trial."""
+    out, finished = {}, {}
+    for trial in sorted(p for p in job_dir.iterdir() if p.is_dir() and (p / "result.json").exists()):
+        result = json.loads((trial / "result.json").read_text())
+        if not result.get("finished_at"):
+            continue
+        # Trial directory names are truncated; the task path is not.
+        name = Path(result["task_id"]["path"]).name
+        if name not in finished or result["finished_at"] > finished[name]:
+            out[name], finished[name] = classify(trial), result["finished_at"]
+    return out
+
+
+def merge(*job_dirs: Path) -> dict[str, dict]:
+    """Verdicts from several jobs; later jobs (re-runs) override earlier ones."""
+    merged = {}
+    for job_dir in job_dirs:
+        merged.update(summarize(job_dir))
+    return merged
+
+
+if __name__ == "__main__":
+    *jobs, out_path = sys.argv[1:]
+    results = merge(*(Path(j) for j in jobs))
+    Path(out_path).write_text(json.dumps(results, indent=2, ensure_ascii=False))
+    print(len(results), "tasks:", dict(collections.Counter(r["cause"] for r in results.values())))

generator/openai_math_harbor/snapshot.py

@@ -0,0 +1,55 @@
+"""Build the shared Daytona snapshot from image/Dockerfile.
+
+Harbor's own auto-snapshot waits only 10 minutes, and downloading Mathlib takes longer, so the
+snapshot is built once up front and passed to Harbor with ``--ek snapshot_template_name=<name>``.
+The name carries a hash of image/, so a changed recipe gets a new snapshot.
+
+    python -m openai_math_harbor.snapshot [--print-name]
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+from pathlib import Path
+
+IMAGE_DIR = Path(__file__).parents[1] / "image"
+
+
+def snapshot_name() -> str:
+    h = hashlib.sha256()
+    # Regular files only: a stray __pycache__ or editor backup must not change or break the hash.
+    for path in sorted(IMAGE_DIR.iterdir()):
+        if path.is_file() and not path.name.startswith(".") and not path.name.endswith((".pyc", "~")):
+            h.update(path.name.encode() + b"\0" + path.read_bytes())
+    return f"openai-math-lean-{h.hexdigest()[:12]}"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--print-name", action="store_true")
+    args = ap.parse_args()
+    name = snapshot_name()
+    if args.print_name:
+        print(name)
+        return
+    from daytona import CreateSnapshotParams, Daytona, Image, Resources
+
+    d = Daytona()
+    try:
+        snap = d.snapshot.get(name)
+        print(f"{name} already exists ({snap.state})")
+        return
+    except Exception:
+        pass
+    image = Image.from_dockerfile(IMAGE_DIR / "Dockerfile")
+    d.snapshot.create(
+        CreateSnapshotParams(name=name, image=image, resources=Resources(cpu=4, memory=8, disk=10)),
+        on_logs=lambda line: print(line, flush=True),
+        timeout=3 * 3600,
+    )
+    print(f"created {name}")
+
+
+if __name__ == "__main__":
+    main()

generator/openai_math_harbor/templates/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

generator/openai_math_harbor/templates/LICENSE-openai-math

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

generator/openai_math_harbor/templates/NOTICE

@@ -0,0 +1,38 @@
+openai-math-harbor
+==================
+
+This dataset packages the Lean statements of OpenAI's "openai/math" release as Harbor tasks.
+
+Redistributed material
+----------------------
+Each task's tests/Challenge.lean, and the Lean block quoted in its instruction.md, is the file
+lean/ComparatorChallenges/<Name>.lean from https://github.com/openai/math at commit
+$source_commit, copyright OpenAI, licensed under the Apache License, Version 2.0 (see
+LICENSE-openai-math). The files are unchanged.
+
+Modified material
+-----------------
+The Comparator configuration of each task (tests/task.json) is derived from the corresponding
+lean/ComparatorChallenges/<Name>.json in that repository. In eight tasks, definitions that the
+original listed under "definition_names" although their bodies are written out were removed from
+that list, so that Comparator requires them to match exactly; task.toml records them under
+[metadata] fixed_definitions.
+
+Only statements whose official proof was verified in the environment are included; the README
+lists the others and why each could not be validated. One challenge (DefocusingNLS) is left out
+by design.
+
+Not included
+------------
+OpenAI's proofs (the lean/OAI library) are not part of this dataset.
+
+Everything else in this dataset (task.toml, instruction.md apart from the quoted statement,
+tests/grade.py, tests/test.sh, environment/, solution/, generator/) is licensed under the
+Apache License, Version 2.0 (see LICENSE).
+
+Third-party software in the sandbox image
+-----------------------------------------
+Lean 4 and Mathlib (Apache-2.0); Comparator and lean4export by the Lean FRO (Apache-2.0),
+Comparator built from leanprover/comparator@d03acab with a one-line patch that passes
+LEAN_NUM_THREADS into its sandbox; landrun (MIT). The image is built from environment/ at run
+time; none of this software is stored in the dataset.

generator/openai_math_harbor/templates/dataset_README.md

@@ -0,0 +1,138 @@
+---
+license: apache-2.0
+task_categories:
+- other
+tags:
+- harbor
+- rl-environment
+- reinforcement-learning
+- code-agent
+- lean4
+- mathlib
+- theorem-proving
+- openai-math
+pretty_name: "openai/math as Harbor environments"
+---
+
+# openai/math as Harbor environments
+
+> **Experimental.** Built on a research release that is itself new and not yet independently
+> reviewed. Expect rough edges, and read any proof that scores 1 before relying on it.
+
+We ported the math problems from OpenAI's [openai/math](https://github.com/openai/math) release
+(commit `$source_commit`) into [Harbor](https://github.com/harbor-framework/harbor) environments.
+The release formalizes **$n_statements** of its results as Lean statements. This dataset contains
+**$n_tasks environments**, the ones whose official proof we verified end to end in the environment,
+covering $n_families result families across $n_subjects fields. The other $n_not_included are listed
+under [Validation](#validation) with the reason each could not be validated.
+
+## How a task works
+
+The agent gets a sandbox with Lean 4 and a prebuilt Mathlib, no internet, and one of OpenAI's
+theorems written in Lean with `sorry` where the proof should be.
+
+**What `sorry` means.** In Lean, `sorry` is a placeholder for a missing proof: it lets the file
+compile as if the step were proven, but nothing has actually been shown, and Lean flags it. The
+statement is given exactly as OpenAI formalized it, and the agent's job is to replace every `sorry`
+with a real proof.
+
+When the agent finishes, a separate, fresh sandbox checks its proof with
+[Comparator](https://github.com/leanprover/comparator), the Lean FRO's proof checker:
+
+- **reward 1** if the theorem has exactly the original statement, the proof uses only Lean's
+  standard axioms (`propext`, `Quot.sound`, `Classical.choice`, so no leftover `sorry` and no new
+  axioms), and the Lean kernel accepts it;
+- **reward 0** otherwise.
+
+OpenAI's own proofs serve as the reference solutions: Harbor's oracle fetches them from GitHub at
+run time. They are not included here and the agent never sees them.
+
+## A strict reward
+
+The grader only accepts a complete proof of the statement exactly as OpenAI formalized it. That
+makes it hard to game, but it is also a real limitation for problems like these:
+
+- a correct proof of an equivalent statement, written with different definitions or a different
+  formulation, scores 0;
+- partial progress (useful lemmas, a proof of a special case, a correct strategy with a gap) scores 0;
+- nothing rewards a creative approach unless it ends in a complete proof of this exact statement.
+
+For open research problems, a more general reward function that recognizes any valid solution to the
+underlying problem, including creative reformulations and partial progress, would be a better
+training signal. We use the strict check here because it is precise and cannot be fooled; treat it
+as one end of that design space.
+
+## What's included
+
+- `tasks/` — one Harbor task per validated problem: instruction, Lean statement, sandbox image recipe,
+  verifier and oracle
+- `registry.json` — Harbor registry entry (`openai-math-harbor@1.0`)
+- `manifest.parquet` — one row per task: field, family, theorem names, reference-proof size, oracle
+  result
+- `generator/` — the code that builds the sandbox image and regenerates the tasks from openai/math
+- `LICENSE`, `NOTICE`, `LICENSE-openai-math` — licensing and attribution
+
+## Run it with the Harbor CLI
+
+You need Harbor 0.24+ with the Daytona backend (`DAYTONA_API_KEY`, `DAYTONA_API_URL`) and
+credentials for the agent you run.
+
+```bash
+pip install "harbor[daytona]>=0.24" daytona
+hf download FineEnvs/openai-math-harbor --repo-type dataset --local-dir openai-math-harbor
+cd openai-math-harbor
+
+# Build the shared sandbox image once (Lean 4, Mathlib, Comparator; ~9 GB, about an hour).
+(cd generator && python -m openai_math_harbor.snapshot)
+SNAP=$$(cd generator && python -m openai_math_harbor.snapshot --print-name)
+
+# Run any agent Harbor supports (`harbor agent list`) on a few tasks:
+harbor run -p tasks -e daytona --ek snapshot_template_name=$$SNAP \
+  -a <agent> -m <model> -i plane-coloring -i hilbert-crouzeix -n 2
+
+# Check that the grader accepts OpenAI's own proof of a task:
+harbor run -p tasks -e daytona --ek snapshot_template_name=$$SNAP \
+  -a oracle --allow-agent-host github.com -i plane-coloring
+```
+
+Each task asks for 4 CPUs, 8 GB of memory and 10 GB of disk, and gives the agent 4 hours. Task
+names are the folder names under `tasks/`.
+
+## Validation
+
+We generated a task for every statement except one left out by design (`DefocusingNLS`, whose
+statement has a `sorry` inside a definition its theorems depend on), and ran Harbor's oracle on each:
+it submits OpenAI's own proof and has it graded by the same verifier an agent faces. Only tasks whose
+official proof was accepted are included.
+
+$validation
+
+$not_validated
+
+The verifier was also tested against submissions that try to cheat (`sorry` in several disguises,
+fake axioms, `native_decide`, weakened statements, redefined definitions, planted reward files, code
+that runs during grading). All scored 0. A no-op agent scores 0.
+
+## Notes
+
+- **Configs.** In eight of openai/math's Comparator configs, definitions written out in the statement
+  were listed as "holes" that Comparator does not check, so a solution could redefine them. Here they
+  must match exactly; affected tasks list them under `fixed_definitions` in `task.toml`.
+- **Contamination.** The statements and proofs have been public since 6 October 2026.
+- **Difficulty.** These are open research problems; expect reward 0 on almost every task.
+
+Technical details (grading design, threat model, image recipe) are in `generator/README.md`.
+
+## License
+
+- The Lean statements are copied unchanged from [openai/math](https://github.com/openai/math)
+  (© OpenAI), licensed under the
+  [Apache License 2.0](https://github.com/openai/math/blob/main/LICENSE); see `LICENSE-openai-math`
+  and `NOTICE`. OpenAI's proofs are not redistributed.
+- The packaging, verifier and generator are Apache-2.0 (`LICENSE`).
+- The sandbox image is built from [Lean 4](https://github.com/leanprover/lean4) and
+  [Mathlib](https://github.com/leanprover-community/mathlib4) (Apache-2.0),
+  [Comparator](https://github.com/leanprover/comparator) and
+  [lean4export](https://github.com/leanprover/lean4export) (Apache-2.0), and
+  [landrun](https://github.com/Zouuup/landrun) (MIT).
+- If you use the results, cite the openai/math manuscripts as that repository asks.

generator/openai_math_harbor/templates/instruction.md

@@ -0,0 +1,52 @@
+# $title
+
+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 $family_number of the release, *$family_title*
+($subject). The family as a whole: $family_summary
+
+The challenge is `$challenge`, also at `/opt/openai-math/challenges/$challenge.lean`:
+
+```lean
+$lean
+```
+
+## What to submit
+
+Write `/workspace/Submission.lean`. Start from a copy of the challenge:
+
+```bash
+cp /opt/openai-math/challenges/$challenge.lean /workspace/Submission.lean
+```
+
+then replace every `sorry` with a proof. The file is graded on three things:
+
+- **Same statements.** $targets 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$holes.
+- **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.

generator/openai_math_harbor/templates/solution/solve.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Oracle: submit openai/math's own proof of $challenge, i.e. module $solution_module and the
+# $n_modules 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 $source_commit
+  git -C "$$tmp" checkout -q FETCH_HEAD
+  python3 /solution/reference.py "$$tmp/lean" /solution/closure.txt $solution_module /workspace
+  rm -rf "$$tmp"
+fi
+echo "placed the reference proof of $challenge"

generator/openai_math_harbor/templates/tests/grade.py

@@ -0,0 +1,356 @@
+#!/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 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"
+# 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 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",
+    ]
+    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),
+    )
+    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_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
+    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.
+            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}"
+    finally:
+        try:
+            kill_grader()
+        except GradingError as exc:
+            reward, details["reason"] = None, f"grading error: {exc}"
+    details["reward"] = reward
+    details["finished_at"] = time.time()
+    (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())

generator/openai_math_harbor/templates/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

generator/tests/test_grade_unpack.py

@@ -0,0 +1,150 @@
+"""The verifier's submission unpacking accepts only regular Submission*.lean files.
+
+    python -m unittest discover -s tests
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import io
+import tarfile
+import tempfile
+import unittest
+from pathlib import Path
+
+GRADE = Path(__file__).parents[1] / "openai_math_harbor" / "templates" / "tests" / "grade.py"
+spec = importlib.util.spec_from_file_location("grade", GRADE)
+grade = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(grade)
+
+
+def make_tar(path: Path, entries: list[tuple[str, str, bytes]]) -> None:
+    """entries: (name, kind, data) with kind in reg/dir/sym/lnk/fifo."""
+    with tarfile.open(path, "w") as tar:
+        for name, kind, data in entries:
+            info = tarfile.TarInfo(name)
+            if kind == "reg":
+                info.size = len(data)
+                tar.addfile(info, io.BytesIO(data))
+                continue
+            info.type = {"dir": tarfile.DIRTYPE, "sym": tarfile.SYMTYPE, "lnk": tarfile.LNKTYPE,
+                         "fifo": tarfile.FIFOTYPE}[kind]
+            info.linkname = data.decode()
+            tar.addfile(info)
+
+
+class UnpackTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+        self.tar = self.tmp / "submission.tar"
+        self.dest = self.tmp / "run"
+        self.dest.mkdir()
+        grade.SUBMISSION_TAR = self.tar
+
+    def unpack(self, entries):
+        make_tar(self.tar, entries)
+        return grade.unpack_submission(self.dest)
+
+    def test_accepts_root_and_modules(self):
+        info = self.unpack([
+            ("Submission.lean", "reg", b"import Submission.A.B\n"),
+            ("Submission", "dir", b""),
+            ("Submission/A/B.lean", "reg", "theorem t : True := trivial -- ℕ\n".encode()),
+        ])
+        self.assertEqual(info["files"], 2)
+        self.assertTrue((self.dest / "Submission" / "A" / "B.lean").is_file())
+
+    def test_accepts_unicode_identifiers(self):
+        info = self.unpack([
+            ("Submission.lean", "reg", b"import Submission.Arith.Kappa\xe2\x82\x81\n"),
+            ("Submission/Arith/Kappa₁.lean", "reg", b"theorem k : True := trivial\n"),
+            ("Submission/αβ/Lemma'.lean", "reg", b""),
+        ])
+        self.assertEqual(info["files"], 3)
+
+    def test_rejections(self):
+        cases = {
+            "missing root": [("Submission/A.lean", "reg", b"")],
+            "path traversal": [("Submission.lean", "reg", b""), ("Submission/../../etc/x.lean", "reg", b"")],
+            "absolute path": [("Submission.lean", "reg", b""), ("/tmp/Submission.lean", "reg", b"")],
+            "symlink": [("Submission.lean", "sym", b"/tests/Challenge.lean")],
+            "hardlink": [("Submission.lean", "reg", b""), ("Submission/X.lean", "lnk", b"Submission.lean")],
+            "fifo": [("Submission.lean", "reg", b""), ("Submission/X.lean", "fifo", b"")],
+            "other root": [("Submission.lean", "reg", b""), ("Challenge.lean", "reg", b"")],
+            "lakefile": [("Submission.lean", "reg", b""), ("lakefile.lean", "reg", b"")],
+            "non-lean": [("Submission.lean", "reg", b""), ("Submission/x.olean", "reg", b"")],
+            "bad module name": [("Submission.lean", "reg", b""), ("Submission/a-b.lean", "reg", b"")],
+            "digit first": [("Submission.lean", "reg", b""), ("Submission/1x.lean", "reg", b"")],
+            "dot component": [("Submission.lean", "reg", b""), ("Submission/../x.lean", "reg", b"")],
+            "space": [("Submission.lean", "reg", b""), ("Submission/a b.lean", "reg", b"")],
+            "non-utf8": [("Submission.lean", "reg", b"\xff\xfe")],
+            "duplicate": [("Submission.lean", "reg", b"a"), ("Submission.lean", "reg", b"b")],
+        }
+        for label, entries in cases.items():
+            with self.subTest(label):
+                for p in self.dest.iterdir():
+                    import shutil
+                    shutil.rmtree(p) if p.is_dir() else p.unlink()
+                with self.assertRaises(grade.Rejected):
+                    self.unpack(entries)
+        self.assertFalse((self.tmp / "etc").exists())
+
+    def test_missing_archive(self):
+        with self.assertRaises(grade.Rejected):
+            grade.unpack_submission(self.dest)
+
+    def test_archive_symlink(self):
+        self.tar.symlink_to("/etc/hostname")
+        with self.assertRaises(grade.Rejected):
+            grade.unpack_submission(self.dest)
+
+    def test_timeout_kills_grandchildren(self):
+        import time
+        # A grandchild holding stdout open is what made the old `timeout`-based call hang.
+        start = time.time()
+        code, out, _ = grade.run_with_timeout(
+            ["bash", "-c", "echo started; (sleep 120; echo late) & sleep 120"],
+            cwd=self.tmp, timeout_sec=2)
+        self.assertIsNone(code)
+        self.assertIn("started", out)
+        self.assertNotIn("late", out)
+        self.assertLess(time.time() - start, 15)
+
+    def test_run_with_timeout_normal_exit(self):
+        code, out, _ = grade.run_with_timeout(["bash", "-c", "echo ok; exit 3"], cwd=self.tmp, timeout_sec=10)
+        self.assertEqual((code, out.strip()), (3, "ok"))
+
+    def test_ensure_readable_touches_only_what_needs_it(self):
+        import os
+        root = self.tmp / "tree"; (root / "sub").mkdir(parents=True)
+        good, bad, writable = root / "good.olean", root / "sub" / "bad.olean", root / "w.olean"
+        for f in (good, bad, writable): f.write_text("x")
+        good.chmod(0o644); bad.chmod(0o600); writable.chmod(0o666)
+        before = os.stat(good).st_ctime_ns
+        changed = grade.ensure_readable((str(root),))
+        self.assertEqual(changed, 2)
+        self.assertEqual(bad.stat().st_mode & 0o777, 0o644)
+        self.assertEqual(writable.stat().st_mode & 0o777, 0o644)
+        self.assertEqual(os.stat(good).st_ctime_ns, before)   # untouched: no overlay copy-up
+        self.assertEqual(grade.ensure_readable((str(root),)), 0)
+
+    def test_out_of_memory_detection(self):
+        self.assertTrue(grade.out_of_memory("✖ Building M\nerror: Lean exited with code 137\n"))
+        self.assertTrue(grade.out_of_memory("uncaught exception: Child exited with 137"))
+        self.assertFalse(grade.out_of_memory("uncaught exception: Child exited with 1"))
+        reward, reason = grade.classify(1, "Building Submission\nerror: Lean exited with code 137\n")
+        self.assertEqual(reward, 0)
+        self.assertIn("out of memory", reason)
+
+    def test_classify(self):
+        ok = "Building Challenge\nBuilding Submission\nYour solution is okay!\n"
+        self.assertEqual(grade.classify(0, ok)[0], 1)
+        self.assertEqual(grade.classify(1, ok)[0], 0)              # success line but nonzero exit
+        self.assertEqual(grade.classify(0, "Building Submission\n")[0], 0)  # exit 0, no success line
+        self.assertEqual(grade.classify(None, ok)[0], 0)            # timeout
+        self.assertIsNone(grade.classify(1, "Building Challenge\nerror\n")[0])  # trusted side broke
+        self.assertIsNone(grade.classify(None, "Building Challenge\n")[0])      # timed out before the submission
+
+
+if __name__ == "__main__":
+    unittest.main()

manifest.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3afe9e43520364a939417dd85aeec87f892c6c81fe54c6f9d0bb67650c4021d0
+size 44329

registry.json

@@ -0,0 +1,1429 @@
+[
+  {
+    "name": "openai-math-harbor",
+    "version": "1.0",
+    "description": "355 Lean 4 theorem-proving tasks from openai/math, graded by Comparator in a separate sandbox.",
+    "tasks": [
+      {
+        "name": "abhyankar-sathaye",
+        "path": "tasks/abhyankar-sathaye"
+      },
+      {
+        "name": "affine-bernstein",
+        "path": "tasks/affine-bernstein"
+      },
+      {
+        "name": "algorithmic-thin-trees",
+        "path": "tasks/algorithmic-thin-trees"
+      },
+      {
+        "name": "amplitude-damping",
+        "path": "tasks/amplitude-damping"
+      },
+      {
+        "name": "artin-cat0",
+        "path": "tasks/artin-cat0"
+      },
+      {
+        "name": "artin-parabolic-intersections",
+        "path": "tasks/artin-parabolic-intersections"
+      },
+      {
+        "name": "asymptotically-minimal-littlewood",
+        "path": "tasks/asymptotically-minimal-littlewood"
+      },
+      {
+        "name": "auslander-reiten",
+        "path": "tasks/auslander-reiten"
+      },
+      {
+        "name": "backward-intertwiners",
+        "path": "tasks/backward-intertwiners"
+      },
+      {
+        "name": "balanced-box-routing",
+        "path": "tasks/balanced-box-routing"
+      },
+      {
+        "name": "balanced-ryser",
+        "path": "tasks/balanced-ryser"
+      },
+      {
+        "name": "balanced-three-stack",
+        "path": "tasks/balanced-three-stack"
+      },
+      {
+        "name": "ball-packing",
+        "path": "tasks/ball-packing"
+      },
+      {
+        "name": "ball-packing-necessity",
+        "path": "tasks/ball-packing-necessity"
+      },
+      {
+        "name": "barnette-hamiltonian",
+        "path": "tasks/barnette-hamiltonian"
+      },
+      {
+        "name": "bass-torsion-free",
+        "path": "tasks/bass-torsion-free"
+      },
+      {
+        "name": "bass-trace",
+        "path": "tasks/bass-trace"
+      },
+      {
+        "name": "benjamini-schramm",
+        "path": "tasks/benjamini-schramm"
+      },
+      {
+        "name": "bernoulli-nonflat-in-seven",
+        "path": "tasks/bernoulli-nonflat-in-seven"
+      },
+      {
+        "name": "biholder-transport",
+        "path": "tasks/biholder-transport"
+      },
+      {
+        "name": "bin-packing-gap",
+        "path": "tasks/bin-packing-gap"
+      },
+      {
+        "name": "binary-edit-lower",
+        "path": "tasks/binary-edit-lower"
+      },
+      {
+        "name": "binary-matching",
+        "path": "tasks/binary-matching"
+      },
+      {
+        "name": "binary-sweep",
+        "path": "tasks/binary-sweep"
+      },
+      {
+        "name": "bipartite-crossing",
+        "path": "tasks/bipartite-crossing"
+      },
+      {
+        "name": "bogomolov-pop-injectivity",
+        "path": "tasks/bogomolov-pop-injectivity"
+      },
+      {
+        "name": "boltzmann-nonuniqueness",
+        "path": "tasks/boltzmann-nonuniqueness"
+      },
+      {
+        "name": "boone-higman",
+        "path": "tasks/boone-higman"
+      },
+      {
+        "name": "borsuk-nine",
+        "path": "tasks/borsuk-nine"
+      },
+      {
+        "name": "bounded-recovery",
+        "path": "tasks/bounded-recovery"
+      },
+      {
+        "name": "bounded-tree-potentials",
+        "path": "tasks/bounded-tree-potentials"
+      },
+      {
+        "name": "bounded-treewidth-l1",
+        "path": "tasks/bounded-treewidth-l1"
+      },
+      {
+        "name": "brenier",
+        "path": "tasks/brenier"
+      },
+      {
+        "name": "brennan",
+        "path": "tasks/brennan"
+      },
+      {
+        "name": "brennan-sharp",
+        "path": "tasks/brennan-sharp"
+      },
+      {
+        "name": "buffered-ising",
+        "path": "tasks/buffered-ising"
+      },
+      {
+        "name": "c0-absorption",
+        "path": "tasks/c0-absorption"
+      },
+      {
+        "name": "c1-entropy-counterexample",
+        "path": "tasks/c1-entropy-counterexample"
+      },
+      {
+        "name": "ch-obstruction",
+        "path": "tasks/ch-obstruction"
+      },
+      {
+        "name": "cks-bondi-penrose",
+        "path": "tasks/cks-bondi-penrose"
+      },
+      {
+        "name": "cannon-geometric-action",
+        "path": "tasks/cannon-geometric-action"
+      },
+      {
+        "name": "cayley-percolation",
+        "path": "tasks/cayley-percolation"
+      },
+      {
+        "name": "character-criterion",
+        "path": "tasks/character-criterion"
+      },
+      {
+        "name": "choiceless-polynomial-time",
+        "path": "tasks/choiceless-polynomial-time"
+      },
+      {
+        "name": "circulant-hadamard",
+        "path": "tasks/circulant-hadamard"
+      },
+      {
+        "name": "classical-on",
+        "path": "tasks/classical-on"
+      },
+      {
+        "name": "clique-free-log",
+        "path": "tasks/clique-free-log"
+      },
+      {
+        "name": "coboundary-expanders",
+        "path": "tasks/coboundary-expanders"
+      },
+      {
+        "name": "common-bases-fpras",
+        "path": "tasks/common-bases-fpras"
+      },
+      {
+        "name": "commuting-derivations",
+        "path": "tasks/commuting-derivations"
+      },
+      {
+        "name": "compact-banach",
+        "path": "tasks/compact-banach"
+      },
+      {
+        "name": "complete-crossing",
+        "path": "tasks/complete-crossing"
+      },
+      {
+        "name": "complete-crouzeix",
+        "path": "tasks/complete-crouzeix"
+      },
+      {
+        "name": "complex-cancellation",
+        "path": "tasks/complex-cancellation"
+      },
+      {
+        "name": "conductivity",
+        "path": "tasks/conductivity"
+      },
+      {
+        "name": "conjugate-points",
+        "path": "tasks/conjugate-points"
+      },
+      {
+        "name": "contingency-tables",
+        "path": "tasks/contingency-tables"
+      },
+      {
+        "name": "continuous-circle-weight",
+        "path": "tasks/continuous-circle-weight"
+      },
+      {
+        "name": "continuum-transition",
+        "path": "tasks/continuum-transition"
+      },
+      {
+        "name": "coordinate-sweeps",
+        "path": "tasks/coordinate-sweeps"
+      },
+      {
+        "name": "coordinate-trace",
+        "path": "tasks/coordinate-trace"
+      },
+      {
+        "name": "cotype",
+        "path": "tasks/cotype"
+      },
+      {
+        "name": "coulomb-counterexample",
+        "path": "tasks/coulomb-counterexample"
+      },
+      {
+        "name": "coulomb-ionization",
+        "path": "tasks/coulomb-ionization"
+      },
+      {
+        "name": "coulomb-radii",
+        "path": "tasks/coulomb-radii"
+      },
+      {
+        "name": "courtade-kumar",
+        "path": "tasks/courtade-kumar"
+      },
+      {
+        "name": "covering-density",
+        "path": "tasks/covering-density"
+      },
+      {
+        "name": "critical-percolation",
+        "path": "tasks/critical-percolation"
+      },
+      {
+        "name": "critical-sk",
+        "path": "tasks/critical-sk"
+      },
+      {
+        "name": "critical-sk-mixing",
+        "path": "tasks/critical-sk-mixing"
+      },
+      {
+        "name": "critical-strip-mass",
+        "path": "tasks/critical-strip-mass"
+      },
+      {
+        "name": "critical-z3",
+        "path": "tasks/critical-z3"
+      },
+      {
+        "name": "crouzeix-hilbert",
+        "path": "tasks/crouzeix-hilbert"
+      },
+      {
+        "name": "cubic-torus",
+        "path": "tasks/cubic-torus"
+      },
+      {
+        "name": "cycle-decomposition",
+        "path": "tasks/cycle-decomposition"
+      },
+      {
+        "name": "cylinder-covering",
+        "path": "tasks/cylinder-covering"
+      },
+      {
+        "name": "daugavet-moduli",
+        "path": "tasks/daugavet-moduli"
+      },
+      {
+        "name": "degree-rigidity",
+        "path": "tasks/degree-rigidity"
+      },
+      {
+        "name": "deligne-drinfeld",
+        "path": "tasks/deligne-drinfeld"
+      },
+      {
+        "name": "depth-five",
+        "path": "tasks/depth-five"
+      },
+      {
+        "name": "depth-three",
+        "path": "tasks/depth-three"
+      },
+      {
+        "name": "diamond-distortion",
+        "path": "tasks/diamond-distortion"
+      },
+      {
+        "name": "diluted-spin",
+        "path": "tasks/diluted-spin"
+      },
+      {
+        "name": "dimension-ten-channel",
+        "path": "tasks/dimension-ten-channel"
+      },
+      {
+        "name": "dimension-ten-pair",
+        "path": "tasks/dimension-ten-pair"
+      },
+      {
+        "name": "direct-crouzeix",
+        "path": "tasks/direct-crouzeix"
+      },
+      {
+        "name": "directed-feedback",
+        "path": "tasks/directed-feedback"
+      },
+      {
+        "name": "directional-ballisticity",
+        "path": "tasks/directional-ballisticity"
+      },
+      {
+        "name": "directional-walk",
+        "path": "tasks/directional-walk"
+      },
+      {
+        "name": "discrete-lipschitz-free",
+        "path": "tasks/discrete-lipschitz-free"
+      },
+      {
+        "name": "disk-maximal",
+        "path": "tasks/disk-maximal"
+      },
+      {
+        "name": "dixmier",
+        "path": "tasks/dixmier"
+      },
+      {
+        "name": "dixmier-all-discrete",
+        "path": "tasks/dixmier-all-discrete"
+      },
+      {
+        "name": "doubling-hilbert",
+        "path": "tasks/doubling-hilbert"
+      },
+      {
+        "name": "dutta-domain",
+        "path": "tasks/dutta-domain"
+      },
+      {
+        "name": "dyadic-avoidance",
+        "path": "tasks/dyadic-avoidance"
+      },
+      {
+        "name": "edit-approximation",
+        "path": "tasks/edit-approximation"
+      },
+      {
+        "name": "edit-distance",
+        "path": "tasks/edit-distance"
+      },
+      {
+        "name": "egyptian-fractions",
+        "path": "tasks/egyptian-fractions"
+      },
+      {
+        "name": "eilenberg-ganea",
+        "path": "tasks/eilenberg-ganea"
+      },
+      {
+        "name": "elasticity-uniqueness",
+        "path": "tasks/elasticity-uniqueness"
+      },
+      {
+        "name": "elementary-positivity",
+        "path": "tasks/elementary-positivity"
+      },
+      {
+        "name": "entangled-games",
+        "path": "tasks/entangled-games"
+      },
+      {
+        "name": "entropy-photon-number",
+        "path": "tasks/entropy-photon-number"
+      },
+      {
+        "name": "euclidean-five-color",
+        "path": "tasks/euclidean-five-color"
+      },
+      {
+        "name": "euclidean-ramsey",
+        "path": "tasks/euclidean-ramsey"
+      },
+      {
+        "name": "euclidean-ramsey-circle",
+        "path": "tasks/euclidean-ramsey-circle"
+      },
+      {
+        "name": "euclidean-ramsey-nine",
+        "path": "tasks/euclidean-ramsey-nine"
+      },
+      {
+        "name": "euclidean-ramsey-quadratic",
+        "path": "tasks/euclidean-ramsey-quadratic"
+      },
+      {
+        "name": "euclidean-ramsey-spherical",
+        "path": "tasks/euclidean-ramsey-spherical"
+      },
+      {
+        "name": "euclidean-ramsey-transitive",
+        "path": "tasks/euclidean-ramsey-transitive"
+      },
+      {
+        "name": "even-barker",
+        "path": "tasks/even-barker"
+      },
+      {
+        "name": "exact-fourier",
+        "path": "tasks/exact-fourier"
+      },
+      {
+        "name": "exact-infiniteness",
+        "path": "tasks/exact-infiniteness"
+      },
+      {
+        "name": "exact-quantum-factoring",
+        "path": "tasks/exact-quantum-factoring"
+      },
+      {
+        "name": "fkcrt",
+        "path": "tasks/fkcrt"
+      },
+      {
+        "name": "factor-generation",
+        "path": "tasks/factor-generation"
+      },
+      {
+        "name": "falconer-all-dimensions",
+        "path": "tasks/falconer-all-dimensions"
+      },
+      {
+        "name": "filling-coefficient",
+        "path": "tasks/filling-coefficient"
+      },
+      {
+        "name": "finite-circle",
+        "path": "tasks/finite-circle"
+      },
+      {
+        "name": "finite-congruence-graph",
+        "path": "tasks/finite-congruence-graph"
+      },
+      {
+        "name": "finite-entropy-separation",
+        "path": "tasks/finite-entropy-separation"
+      },
+      {
+        "name": "finite-factor",
+        "path": "tasks/finite-factor"
+      },
+      {
+        "name": "finitistic-asymmetry",
+        "path": "tasks/finitistic-asymmetry"
+      },
+      {
+        "name": "fixed-clause-threshold",
+        "path": "tasks/fixed-clause-threshold"
+      },
+      {
+        "name": "forced-navier-stokes-computation",
+        "path": "tasks/forced-navier-stokes-computation"
+      },
+      {
+        "name": "forest-space",
+        "path": "tasks/forest-space"
+      },
+      {
+        "name": "formula-hitting",
+        "path": "tasks/formula-hitting"
+      },
+      {
+        "name": "foulkes-howe",
+        "path": "tasks/foulkes-howe"
+      },
+      {
+        "name": "four-row-permanent",
+        "path": "tasks/four-row-permanent"
+      },
+      {
+        "name": "free-ising",
+        "path": "tasks/free-ising"
+      },
+      {
+        "name": "free-uniform-spanning-forest",
+        "path": "tasks/free-uniform-spanning-forest"
+      },
+      {
+        "name": "gamma-passage",
+        "path": "tasks/gamma-passage"
+      },
+      {
+        "name": "gaussian-finite-entropy",
+        "path": "tasks/gaussian-finite-entropy"
+      },
+      {
+        "name": "gaussian-information",
+        "path": "tasks/gaussian-information"
+      },
+      {
+        "name": "gaussian-moat",
+        "path": "tasks/gaussian-moat"
+      },
+      {
+        "name": "gaussian-propeller",
+        "path": "tasks/gaussian-propeller"
+      },
+      {
+        "name": "gaussian-replacement",
+        "path": "tasks/gaussian-replacement"
+      },
+      {
+        "name": "general-mahler",
+        "path": "tasks/general-mahler"
+      },
+      {
+        "name": "generalized-star-height",
+        "path": "tasks/generalized-star-height"
+      },
+      {
+        "name": "gotsman-linial",
+        "path": "tasks/gotsman-linial"
+      },
+      {
+        "name": "graham-spherical",
+        "path": "tasks/graham-spherical"
+      },
+      {
+        "name": "grothendieck-elementary-expansion",
+        "path": "tasks/grothendieck-elementary-expansion"
+      },
+      {
+        "name": "group-ring-determinant",
+        "path": "tasks/group-ring-determinant"
+      },
+      {
+        "name": "hadamard-cube-fiber",
+        "path": "tasks/hadamard-cube-fiber"
+      },
+      {
+        "name": "halving-lines",
+        "path": "tasks/halving-lines"
+      },
+      {
+        "name": "hard-sphere",
+        "path": "tasks/hard-sphere"
+      },
+      {
+        "name": "harmonic-artin",
+        "path": "tasks/harmonic-artin"
+      },
+      {
+        "name": "harmonic-growth",
+        "path": "tasks/harmonic-growth"
+      },
+      {
+        "name": "heilbronn-triangle",
+        "path": "tasks/heilbronn-triangle"
+      },
+      {
+        "name": "heisenberg",
+        "path": "tasks/heisenberg"
+      },
+      {
+        "name": "henon-emden",
+        "path": "tasks/henon-emden"
+      },
+      {
+        "name": "hilbert-crouzeix",
+        "path": "tasks/hilbert-crouzeix"
+      },
+      {
+        "name": "honeycomb-bridge-finiteness",
+        "path": "tasks/honeycomb-bridge-finiteness"
+      },
+      {
+        "name": "honeycomb-free-energy",
+        "path": "tasks/honeycomb-free-energy"
+      },
+      {
+        "name": "hot-spots",
+        "path": "tasks/hot-spots"
+      },
+      {
+        "name": "hyperbolic-cones",
+        "path": "tasks/hyperbolic-cones"
+      },
+      {
+        "name": "hyperbolic-obstruction",
+        "path": "tasks/hyperbolic-obstruction"
+      },
+      {
+        "name": "hyperinvariant-subspaces",
+        "path": "tasks/hyperinvariant-subspaces"
+      },
+      {
+        "name": "independent-products",
+        "path": "tasks/independent-products"
+      },
+      {
+        "name": "independent-sets",
+        "path": "tasks/independent-sets"
+      },
+      {
+        "name": "individual-strong-infiniteness",
+        "path": "tasks/individual-strong-infiniteness"
+      },
+      {
+        "name": "infinite-matroid",
+        "path": "tasks/infinite-matroid"
+      },
+      {
+        "name": "infinite-matroid-corollaries",
+        "path": "tasks/infinite-matroid-corollaries"
+      },
+      {
+        "name": "interpolated-factors",
+        "path": "tasks/interpolated-factors"
+      },
+      {
+        "name": "irrational-rotation",
+        "path": "tasks/irrational-rotation"
+      },
+      {
+        "name": "irrational-triangle-billiard",
+        "path": "tasks/irrational-triangle-billiard"
+      },
+      {
+        "name": "ising-finiteness",
+        "path": "tasks/ising-finiteness"
+      },
+      {
+        "name": "isometric-immersion",
+        "path": "tasks/isometric-immersion"
+      },
+      {
+        "name": "kl-invariance",
+        "path": "tasks/kl-invariance"
+      },
+      {
+        "name": "k-median-recovery",
+        "path": "tasks/k-median-recovery"
+      },
+      {
+        "name": "k-median-refined-recovery",
+        "path": "tasks/k-median-refined-recovery"
+      },
+      {
+        "name": "k-median-threshold",
+        "path": "tasks/k-median-threshold"
+      },
+      {
+        "name": "k-server",
+        "path": "tasks/k-server"
+      },
+      {
+        "name": "kadison-ringrose",
+        "path": "tasks/kadison-ringrose"
+      },
+      {
+        "name": "kadison-similarity",
+        "path": "tasks/kadison-similarity"
+      },
+      {
+        "name": "kahler-splitting",
+        "path": "tasks/kahler-splitting"
+      },
+      {
+        "name": "kaplansky-direct-finiteness",
+        "path": "tasks/kaplansky-direct-finiteness"
+      },
+      {
+        "name": "kaplansky-finitely-presented",
+        "path": "tasks/kaplansky-finitely-presented"
+      },
+      {
+        "name": "kaplansky-quasitrace",
+        "path": "tasks/kaplansky-quasitrace"
+      },
+      {
+        "name": "kaplansky-stable-finiteness",
+        "path": "tasks/kaplansky-stable-finiteness"
+      },
+      {
+        "name": "kervaire",
+        "path": "tasks/kervaire"
+      },
+      {
+        "name": "laughlin",
+        "path": "tasks/laughlin"
+      },
+      {
+        "name": "laughlin-fock",
+        "path": "tasks/laughlin-fock"
+      },
+      {
+        "name": "laughlin-gap",
+        "path": "tasks/laughlin-gap"
+      },
+      {
+        "name": "laughlin-planar",
+        "path": "tasks/laughlin-planar"
+      },
+      {
+        "name": "lieb-thirring",
+        "path": "tasks/lieb-thirring"
+      },
+      {
+        "name": "lipschitz-equivalence",
+        "path": "tasks/lipschitz-equivalence"
+      },
+      {
+        "name": "lipschitz-hilbert",
+        "path": "tasks/lipschitz-hilbert"
+      },
+      {
+        "name": "list-hadwiger",
+        "path": "tasks/list-hadwiger"
+      },
+      {
+        "name": "little-finitistic",
+        "path": "tasks/little-finitistic"
+      },
+      {
+        "name": "littlewood-finite-flatness",
+        "path": "tasks/littlewood-finite-flatness"
+      },
+      {
+        "name": "log-brunn-minkowski",
+        "path": "tasks/log-brunn-minkowski"
+      },
+      {
+        "name": "log-concave-query",
+        "path": "tasks/log-concave-query"
+      },
+      {
+        "name": "log-kodaira-fiber-negative",
+        "path": "tasks/log-kodaira-fiber-negative"
+      },
+      {
+        "name": "mahler-conjecture",
+        "path": "tasks/mahler-conjecture"
+      },
+      {
+        "name": "markov-type",
+        "path": "tasks/markov-type"
+      },
+      {
+        "name": "mass-action",
+        "path": "tasks/mass-action"
+      },
+      {
+        "name": "matching-affine-lift",
+        "path": "tasks/matching-affine-lift"
+      },
+      {
+        "name": "matching-entropy",
+        "path": "tasks/matching-entropy"
+      },
+      {
+        "name": "matching-entropy-bounds",
+        "path": "tasks/matching-entropy-bounds"
+      },
+      {
+        "name": "matching-fpras",
+        "path": "tasks/matching-fpras"
+      },
+      {
+        "name": "matching-psd",
+        "path": "tasks/matching-psd"
+      },
+      {
+        "name": "matrix-fields",
+        "path": "tasks/matrix-fields"
+      },
+      {
+        "name": "matrix-removal",
+        "path": "tasks/matrix-removal"
+      },
+      {
+        "name": "matroid-prophet",
+        "path": "tasks/matroid-prophet"
+      },
+      {
+        "name": "matroid-secretary",
+        "path": "tasks/matroid-secretary"
+      },
+      {
+        "name": "maximal-seshadri-constants",
+        "path": "tasks/maximal-seshadri-constants"
+      },
+      {
+        "name": "memory-precision",
+        "path": "tasks/memory-precision"
+      },
+      {
+        "name": "metric-entropy-duality",
+        "path": "tasks/metric-entropy-duality"
+      },
+      {
+        "name": "metric-k-median",
+        "path": "tasks/metric-k-median"
+      },
+      {
+        "name": "midpoint-lenses",
+        "path": "tasks/midpoint-lenses"
+      },
+      {
+        "name": "min-uncut",
+        "path": "tasks/min-uncut"
+      },
+      {
+        "name": "nagata",
+        "path": "tasks/nagata"
+      },
+      {
+        "name": "naimark",
+        "path": "tasks/naimark"
+      },
+      {
+        "name": "navier-stokes-alternating",
+        "path": "tasks/navier-stokes-alternating"
+      },
+      {
+        "name": "navier-stokes-velocity",
+        "path": "tasks/navier-stokes-velocity"
+      },
+      {
+        "name": "nodal-length",
+        "path": "tasks/nodal-length"
+      },
+      {
+        "name": "noiseless-regression",
+        "path": "tasks/noiseless-regression"
+      },
+      {
+        "name": "odd-kaplansky",
+        "path": "tasks/odd-kaplansky"
+      },
+      {
+        "name": "one-way-liveness",
+        "path": "tasks/one-way-liveness"
+      },
+      {
+        "name": "optimal-max-cut",
+        "path": "tasks/optimal-max-cut"
+      },
+      {
+        "name": "ordinary-elliott",
+        "path": "tasks/ordinary-elliott"
+      },
+      {
+        "name": "parity-lifts",
+        "path": "tasks/parity-lifts"
+      },
+      {
+        "name": "partial-permutation",
+        "path": "tasks/partial-permutation"
+      },
+      {
+        "name": "partition-consistency",
+        "path": "tasks/partition-consistency"
+      },
+      {
+        "name": "partition-principle",
+        "path": "tasks/partition-principle"
+      },
+      {
+        "name": "perceptron-free-energy",
+        "path": "tasks/perceptron-free-energy"
+      },
+      {
+        "name": "perfect-completeness",
+        "path": "tasks/perfect-completeness"
+      },
+      {
+        "name": "periodic-group",
+        "path": "tasks/periodic-group"
+      },
+      {
+        "name": "periodic-tiling-three",
+        "path": "tasks/periodic-tiling-three"
+      },
+      {
+        "name": "permanent-cubic",
+        "path": "tasks/permanent-cubic"
+      },
+      {
+        "name": "petty-projection-volume",
+        "path": "tasks/petty-projection-volume"
+      },
+      {
+        "name": "pi-exponent",
+        "path": "tasks/pi-exponent"
+      },
+      {
+        "name": "pinched-kahler",
+        "path": "tasks/pinched-kahler"
+      },
+      {
+        "name": "pinned-distances",
+        "path": "tasks/pinned-distances"
+      },
+      {
+        "name": "planar-anderson-spectrum",
+        "path": "tasks/planar-anderson-spectrum"
+      },
+      {
+        "name": "planar-falconer",
+        "path": "tasks/planar-falconer"
+      },
+      {
+        "name": "planar-first-passage",
+        "path": "tasks/planar-first-passage"
+      },
+      {
+        "name": "planar-l1",
+        "path": "tasks/planar-l1"
+      },
+      {
+        "name": "planar-unit-distances",
+        "path": "tasks/planar-unit-distances"
+      },
+      {
+        "name": "plane-coloring",
+        "path": "tasks/plane-coloring"
+      },
+      {
+        "name": "posterior-replicas",
+        "path": "tasks/posterior-replicas"
+      },
+      {
+        "name": "power-free-values",
+        "path": "tasks/power-free-values"
+      },
+      {
+        "name": "prime-gaps",
+        "path": "tasks/prime-gaps"
+      },
+      {
+        "name": "product-brown",
+        "path": "tasks/product-brown"
+      },
+      {
+        "name": "projection-counterexample",
+        "path": "tasks/projection-counterexample"
+      },
+      {
+        "name": "projection-moments",
+        "path": "tasks/projection-moments"
+      },
+      {
+        "name": "projection-volume",
+        "path": "tasks/projection-volume"
+      },
+      {
+        "name": "qac-parity",
+        "path": "tasks/qac-parity"
+      },
+      {
+        "name": "quadric-bundles",
+        "path": "tasks/quadric-bundles"
+      },
+      {
+        "name": "quantitative-van-der-waerden",
+        "path": "tasks/quantitative-van-der-waerden"
+      },
+      {
+        "name": "quintic-lienard",
+        "path": "tasks/quintic-lienard"
+      },
+      {
+        "name": "radial-density-interval",
+        "path": "tasks/radial-density-interval"
+      },
+      {
+        "name": "radial-transition",
+        "path": "tasks/radial-transition"
+      },
+      {
+        "name": "randomized-mean-payoff",
+        "path": "tasks/randomized-mean-payoff"
+      },
+      {
+        "name": "rational-hitting",
+        "path": "tasks/rational-hitting"
+      },
+      {
+        "name": "real-l1-renorming",
+        "path": "tasks/real-l1-renorming"
+      },
+      {
+        "name": "recursive-potentials",
+        "path": "tasks/recursive-potentials"
+      },
+      {
+        "name": "reflexive-fixed-points",
+        "path": "tasks/reflexive-fixed-points"
+      },
+      {
+        "name": "regular-parity",
+        "path": "tasks/regular-parity"
+      },
+      {
+        "name": "relative-generation",
+        "path": "tasks/relative-generation"
+      },
+      {
+        "name": "rokhlin",
+        "path": "tasks/rokhlin"
+      },
+      {
+        "name": "ruled-covering",
+        "path": "tasks/ruled-covering"
+      },
+      {
+        "name": "ryser-covering",
+        "path": "tasks/ryser-covering"
+      },
+      {
+        "name": "ryser-odd-extensions",
+        "path": "tasks/ryser-odd-extensions"
+      },
+      {
+        "name": "sat-sharpness",
+        "path": "tasks/sat-sharpness"
+      },
+      {
+        "name": "sat-variance",
+        "path": "tasks/sat-variance"
+      },
+      {
+        "name": "sk-full-support",
+        "path": "tasks/sk-full-support"
+      },
+      {
+        "name": "sk-value",
+        "path": "tasks/sk-value"
+      },
+      {
+        "name": "sle-lower-positivity",
+        "path": "tasks/sle-lower-positivity"
+      },
+      {
+        "name": "saxl",
+        "path": "tasks/saxl"
+      },
+      {
+        "name": "second-kahn-kalai",
+        "path": "tasks/second-kahn-kalai"
+      },
+      {
+        "name": "self-similar",
+        "path": "tasks/self-similar"
+      },
+      {
+        "name": "self-similar-corollaries",
+        "path": "tasks/self-similar-corollaries"
+      },
+      {
+        "name": "sensitivity-separation",
+        "path": "tasks/sensitivity-separation"
+      },
+      {
+        "name": "separable-quotient-negative",
+        "path": "tasks/separable-quotient-negative"
+      },
+      {
+        "name": "seymour-second-neighborhood",
+        "path": "tasks/seymour-second-neighborhood"
+      },
+      {
+        "name": "sharp-cat0-filling",
+        "path": "tasks/sharp-cat0-filling"
+      },
+      {
+        "name": "sharp-threshold",
+        "path": "tasks/sharp-threshold"
+      },
+      {
+        "name": "short-egyptian-fractions",
+        "path": "tasks/short-egyptian-fractions"
+      },
+      {
+        "name": "sidorenko-counterexample",
+        "path": "tasks/sidorenko-counterexample"
+      },
+      {
+        "name": "signed-finite-band",
+        "path": "tasks/signed-finite-band"
+      },
+      {
+        "name": "signed-sweep-moment",
+        "path": "tasks/signed-sweep-moment"
+      },
+      {
+        "name": "single-fold",
+        "path": "tasks/single-fold"
+      },
+      {
+        "name": "single-lattice-covering",
+        "path": "tasks/single-lattice-covering"
+      },
+      {
+        "name": "singleton-loop-matching",
+        "path": "tasks/singleton-loop-matching"
+      },
+      {
+        "name": "smooth-initial-form",
+        "path": "tasks/smooth-initial-form"
+      },
+      {
+        "name": "smooth-obstruction",
+        "path": "tasks/smooth-obstruction"
+      },
+      {
+        "name": "soft-channel204",
+        "path": "tasks/soft-channel204"
+      },
+      {
+        "name": "solenoidal-sheet-programs",
+        "path": "tasks/solenoidal-sheet-programs"
+      },
+      {
+        "name": "spherical-field",
+        "path": "tasks/spherical-field"
+      },
+      {
+        "name": "split-tangent-integrability",
+        "path": "tasks/split-tangent-integrability"
+      },
+      {
+        "name": "square-difference",
+        "path": "tasks/square-difference"
+      },
+      {
+        "name": "square-root-degree",
+        "path": "tasks/square-root-degree"
+      },
+      {
+        "name": "standard-map-entropy",
+        "path": "tasks/standard-map-entropy"
+      },
+      {
+        "name": "standard-map-lyapunov",
+        "path": "tasks/standard-map-lyapunov"
+      },
+      {
+        "name": "steinitz-bergstrom",
+        "path": "tasks/steinitz-bergstrom"
+      },
+      {
+        "name": "strict-means",
+        "path": "tasks/strict-means"
+      },
+      {
+        "name": "strong-thin-tree",
+        "path": "tasks/strong-thin-tree"
+      },
+      {
+        "name": "strongly-rayleigh-dpp",
+        "path": "tasks/strongly-rayleigh-dpp"
+      },
+      {
+        "name": "structural-crouzeix",
+        "path": "tasks/structural-crouzeix"
+      },
+      {
+        "name": "subpolynomial-lp",
+        "path": "tasks/subpolynomial-lp"
+      },
+      {
+        "name": "subsphere-current",
+        "path": "tasks/subsphere-current"
+      },
+      {
+        "name": "superstring",
+        "path": "tasks/superstring"
+      },
+      {
+        "name": "switch-chain",
+        "path": "tasks/switch-chain"
+      },
+      {
+        "name": "symmetric-domains",
+        "path": "tasks/symmetric-domains"
+      },
+      {
+        "name": "symmetric-mahler-equality",
+        "path": "tasks/symmetric-mahler-equality"
+      },
+      {
+        "name": "symmetric-polar",
+        "path": "tasks/symmetric-polar"
+      },
+      {
+        "name": "tachikawa",
+        "path": "tasks/tachikawa"
+      },
+      {
+        "name": "talagrand-discrete-convexity",
+        "path": "tasks/talagrand-discrete-convexity"
+      },
+      {
+        "name": "talagrand-expectation-threshold",
+        "path": "tasks/talagrand-expectation-threshold"
+      },
+      {
+        "name": "thomason-model-structures",
+        "path": "tasks/thomason-model-structures"
+      },
+      {
+        "name": "thompson-nonamenability",
+        "path": "tasks/thompson-nonamenability"
+      },
+      {
+        "name": "thorp-first-reciprocal",
+        "path": "tasks/thorp-first-reciprocal"
+      },
+      {
+        "name": "thorp-remaining",
+        "path": "tasks/thorp-remaining"
+      },
+      {
+        "name": "thorp-routing",
+        "path": "tasks/thorp-routing"
+      },
+      {
+        "name": "thorp-weighted-compatibility",
+        "path": "tasks/thorp-weighted-compatibility"
+      },
+      {
+        "name": "three-machine",
+        "path": "tasks/three-machine"
+      },
+      {
+        "name": "three-state-supercritical",
+        "path": "tasks/three-state-supercritical"
+      },
+      {
+        "name": "three-state-tree-clauses",
+        "path": "tasks/three-state-tree-clauses"
+      },
+      {
+        "name": "three-torus",
+        "path": "tasks/three-torus"
+      },
+      {
+        "name": "tingley-sphere-isometry",
+        "path": "tasks/tingley-sphere-isometry"
+      },
+      {
+        "name": "torsion-free-hyperbolic",
+        "path": "tasks/torsion-free-hyperbolic"
+      },
+      {
+        "name": "torsion-free-zero-divisors",
+        "path": "tasks/torsion-free-zero-divisors"
+      },
+      {
+        "name": "trace-reconstruction",
+        "path": "tasks/trace-reconstruction"
+      },
+      {
+        "name": "tree-edit",
+        "path": "tasks/tree-edit"
+      },
+      {
+        "name": "triangle-face",
+        "path": "tasks/triangle-face"
+      },
+      {
+        "name": "triangle-removal",
+        "path": "tasks/triangle-removal"
+      },
+      {
+        "name": "triangular-covering",
+        "path": "tasks/triangular-covering"
+      },
+      {
+        "name": "triangular-energy",
+        "path": "tasks/triangular-energy"
+      },
+      {
+        "name": "triangular-gaussian",
+        "path": "tasks/triangular-gaussian"
+      },
+      {
+        "name": "triangular-hilbert",
+        "path": "tasks/triangular-hilbert"
+      },
+      {
+        "name": "truffet-counterexample",
+        "path": "tasks/truffet-counterexample"
+      },
+      {
+        "name": "two-way-complementation",
+        "path": "tasks/two-way-complementation"
+      },
+      {
+        "name": "two-way-determinization",
+        "path": "tasks/two-way-determinization"
+      },
+      {
+        "name": "type-system-normalization",
+        "path": "tasks/type-system-normalization"
+      },
+      {
+        "name": "uniform-commutator",
+        "path": "tasks/uniform-commutator"
+      },
+      {
+        "name": "uniform-gamma",
+        "path": "tasks/uniform-gamma"
+      },
+      {
+        "name": "uniform-k-server",
+        "path": "tasks/uniform-k-server"
+      },
+      {
+        "name": "uniform-sparsest-cut",
+        "path": "tasks/uniform-sparsest-cut"
+      },
+      {
+        "name": "unique-games-theorem",
+        "path": "tasks/unique-games-theorem"
+      },
+      {
+        "name": "universal-f-infinity",
+        "path": "tasks/universal-f-infinity"
+      },
+      {
+        "name": "variable-wl",
+        "path": "tasks/variable-wl"
+      },
+      {
+        "name": "velocity-hemisphere",
+        "path": "tasks/velocity-hemisphere"
+      },
+      {
+        "name": "vertex-algebra-net",
+        "path": "tasks/vertex-algebra-net"
+      },
+      {
+        "name": "vertex-cover",
+        "path": "tasks/vertex-cover"
+      },
+      {
+        "name": "vlasov-maxwell",
+        "path": "tasks/vlasov-maxwell"
+      },
+      {
+        "name": "wl-identification",
+        "path": "tasks/wl-identification"
+      },
+      {
+        "name": "weak-hessian",
+        "path": "tasks/weak-hessian"
+      },
+      {
+        "name": "weak-mtw-global-support",
+        "path": "tasks/weak-mtw-global-support"
+      },
+      {
+        "name": "weighted-sweep-moments",
+        "path": "tasks/weighted-sweep-moments"
+      },
+      {
+        "name": "weisfeiler-leman",
+        "path": "tasks/weisfeiler-leman"
+      },
+      {
+        "name": "witnessed-choice",
+        "path": "tasks/witnessed-choice"
+      },
+      {
+        "name": "yau-counterexample",
+        "path": "tasks/yau-counterexample"
+      }
+    ]
+  }
+]

tasks/abhyankar-sathaye/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/abhyankar-sathaye/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/abhyankar-sathaye/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/abhyankar-sathaye/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/abhyankar-sathaye/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/abhyankar-sathaye/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/abhyankar-sathaye/instruction.md

@@ -0,0 +1,72 @@
+# openai/math challenge `AbhyankarSathaye` (family 049)
+
+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 049 of the release, *A stable-coordinate counterexample in four variables*
+(Algebraic and complex geometry). The family as a whole: Constructs a polynomial in four complex variables that is not a coordinate but becomes one after adjoining a single variable, disproving the Stable Coordinate conjecture in four variables. Every fiber is affine three-space, yet none of its embeddings is rectifiable, also disproving the Abhyankar–Sathaye conjecture even when all fibers are affine spaces.
+
+The challenge is `AbhyankarSathaye`, also at `/opt/openai-math/challenges/AbhyankarSathaye.lean`:
+
+```lean
+import Mathlib.Algebra.MvPolynomial.CommRing
+import Mathlib.Basic.Complex.Basic
+import Mathlib.RingTheory.Ideal.Quotient.Operations
+
+namespace OAI
+
+namespace AbhyankarSathaye
+
+/-- In every dimension at least four, a polynomial can define affine space
+without being a coordinate of the ambient polynomial ring. -/
+theorem exists_noncoordinate_polynomial (n : ℕ) (hn : 4 ≤ n) :
+    ∃ F : MvPolynomial (Fin n) ℂ,
+      Nonempty ((MvPolynomial (Fin n) ℂ ⧸ Ideal.span {F}) ≃ₐ[ℂ]
+        MvPolynomial (Fin (n - 1)) ℂ) ∧
+      ¬ ∃ (equiv : MvPolynomial (Fin n) ℂ ≃ₐ[ℂ] MvPolynomial (Fin n) ℂ)
+        (index : Fin n), equiv (MvPolynomial.X index) = F := by
+  sorry
+
+end AbhyankarSathaye
+
+end OAI
+```
+
+## What to submit
+
+Write `/workspace/Submission.lean`. Start from a copy of the challenge:
+
+```bash
+cp /opt/openai-math/challenges/AbhyankarSathaye.lean /workspace/Submission.lean
+```
+
+then replace every `sorry` with a proof. The file is graded on three things:
+
+- **Same statements.** The theorem `OAI.AbhyankarSathaye.exists_noncoordinate_polynomial` 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/abhyankar-sathaye/solution/closure.txt

@@ -0,0 +1,15 @@
+OAI.AlgebraicGeometry.AbhyankarSathaye.Counterexample
+OAI.AlgebraicGeometry.AbhyankarSathaye.CriticalPoint
+OAI.AlgebraicGeometry.AbhyankarSathaye.Fiber
+OAI.AlgebraicGeometry.AbhyankarSathaye.FiberFormulas
+OAI.AlgebraicGeometry.AbhyankarSathaye.Identities
+OAI.AlgebraicGeometry.AbhyankarSathaye.Lifting
+OAI.AlgebraicGeometry.AbhyankarSathaye.LiftingIdentities
+OAI.AlgebraicGeometry.AbhyankarSathaye.LinearElimination
+OAI.AlgebraicGeometry.AbhyankarSathaye.LinearPresentation
+OAI.AlgebraicGeometry.AbhyankarSathaye.NonCoordinate
+OAI.AlgebraicGeometry.AbhyankarSathaye.Plane
+OAI.AlgebraicGeometry.AbhyankarSathaye.Presentation
+OAI.AlgebraicGeometry.AbhyankarSathaye.Quotient
+OAI.AlgebraicGeometry.AbhyankarSathaye.Reconstruction
+OAI.AlgebraicGeometry.AbhyankarSathaye.Stabilization

tasks/abhyankar-sathaye/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/abhyankar-sathaye/solution/solve.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Oracle: submit openai/math's own proof of AbhyankarSathaye, i.e. module OAI.AlgebraicGeometry.AbhyankarSathaye.Counterexample and the
+# 15 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.AlgebraicGeometry.AbhyankarSathaye.Counterexample /workspace
+  rm -rf "$tmp"
+fi
+echo "placed the reference proof of AbhyankarSathaye"

tasks/abhyankar-sathaye/task.toml

@@ -0,0 +1,49 @@
+schema_version = "1.4"
+
+[task]
+name = "openai-math/abhyankar-sathaye"
+version = "1.0.0"
+description = "Prove AbhyankarSathaye (openai/math family 049: A stable-coordinate counterexample in four variables) in Lean 4 with Mathlib; graded by Comparator in a separate sandbox."
+keywords = ["lean4", "mathlib", "theorem-proving", "openai-math", "algebraic-and-complex-geometry"]
+
+[metadata]
+source = "https://github.com/openai/math"
+source_commit = "adc7f1241b42e322a6451854ab7e4b4c146bf78a"
+source_license = "Apache-2.0"
+source_notice = "tests/Challenge.lean is lean/ComparatorChallenges/AbhyankarSathaye.lean from openai/math, (c) OpenAI, unchanged; see NOTICE at the dataset root"
+challenge = "AbhyankarSathaye"
+family = "049"
+family_title = "A stable-coordinate counterexample in four variables"
+subject = "Algebraic and complex geometry"
+theorems = ["OAI.AbhyankarSathaye.exists_noncoordinate_polynomial"]
+definition_holes = []
+fixed_definitions = []
+reference_module = "OAI.AlgebraicGeometry.AbhyankarSathaye.Counterexample"
+reference_modules = 15
+reference_lean_bytes = 55824
+reference_requires_packages = []
+oracle_result = "accepted"
+oracle_grade_seconds = 463
+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 = 11750
+environment_mode = "separate"
+network_mode = "no-network"
+
+[[verifier.collect]]
+command = "python3 /opt/openai-math/pack_submission.py"
+timeout_sec = 300

tasks/abhyankar-sathaye/tests/Challenge.lean

@@ -0,0 +1,21 @@
+import Mathlib.Algebra.MvPolynomial.CommRing
+import Mathlib.Basic.Complex.Basic
+import Mathlib.RingTheory.Ideal.Quotient.Operations
+
+namespace OAI
+
+namespace AbhyankarSathaye
+
+/-- In every dimension at least four, a polynomial can define affine space
+without being a coordinate of the ambient polynomial ring. -/
+theorem exists_noncoordinate_polynomial (n : ℕ) (hn : 4 ≤ n) :
+    ∃ F : MvPolynomial (Fin n) ℂ,
+      Nonempty ((MvPolynomial (Fin n) ℂ ⧸ Ideal.span {F}) ≃ₐ[ℂ]
+        MvPolynomial (Fin (n - 1)) ℂ) ∧
+      ¬ ∃ (equiv : MvPolynomial (Fin n) ℂ ≃ₐ[ℂ] MvPolynomial (Fin n) ℂ)
+        (index : Fin n), equiv (MvPolynomial.X index) = F := by
+  sorry
+
+end AbhyankarSathaye
+
+end OAI

tasks/abhyankar-sathaye/tests/grade.py

@@ -0,0 +1,356 @@
+#!/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 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"
+# 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 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",
+    ]
+    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),
+    )
+    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_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
+    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.
+            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}"
+    finally:
+        try:
+            kill_grader()
+        except GradingError as exc:
+            reward, details["reason"] = None, f"grading error: {exc}"
+    details["reward"] = reward
+    details["finished_at"] = time.time()
+    (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/abhyankar-sathaye/tests/task.json

@@ -0,0 +1,15 @@
+{
+  "challenge": "AbhyankarSathaye",
+  "comparator": {
+    "theorem_names": [
+      "OAI.AbhyankarSathaye.exists_noncoordinate_polynomial"
+    ],
+    "definition_names": [],
+    "permitted_axioms": [
+      "propext",
+      "Quot.sound",
+      "Classical.choice"
+    ]
+  },
+  "grade_timeout_sec": 10850
+}

tasks/abhyankar-sathaye/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/affine-bernstein/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/affine-bernstein/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