benchmarks: add Hodge blow-up divisor certificate

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/README.md

@@ -0,0 +1,12 @@
+# Hodge blow-up divisor certificate
+
+Assurance benchmark from retained row C-039. Its single objective is exact
+algebraic-cycle certification: polynomial incidence and simple multiplicity at
+six points, followed by divisor-class, intersection, and adjunction replay.
+Alternative primitive cubics satisfying the same contract are accepted.
+
+Difficulty is provisional Hard because symbolic polynomial evaluation,
+derivatives, blow-up signs, canonical pairing, genus, and scope calibration
+must all align. Lefschetz (1,1) is trusted; no higher-codimension Hodge claim is
+made. Source: <https://www.claymath.org/millennium-problems/hodge-conjecture/>,
+status checked 2026-08-06.

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/environment/Dockerfile

@@ -0,0 +1,3 @@
+FROM python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
+COPY input.json submission_schema.json /app/
+WORKDIR /app

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/environment/input.json

@@ -0,0 +1 @@
+{"task_id":"jacobian/hodge-blowup-divisor-certificate","conjecture_id":"C-039","degree":3,"monomial_order":["x^3","x^2y","x^2z","xy^2","xyz","xz^2","y^3","y^2z","yz^2","z^3"],"blowup_points":[[0,0,1],[1,0,1],[0,1,1],[1,1,1],[2,0,1],[0,2,1]],"coefficient_bound":20,"scope":"six-point-p2-blowup-divisor-v1"}

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/environment/submission_schema.json

@@ -0,0 +1,156 @@
+{
+  "$defs": {
+    "point_check": {
+      "additionalProperties": false,
+      "properties": {
+        "gradient": {
+          "items": {
+            "type": "integer"
+          },
+          "maxItems": 3,
+          "minItems": 3,
+          "type": "array"
+        },
+        "multiplicity": {
+          "const": 1
+        },
+        "point_index": {
+          "maximum": 5,
+          "minimum": 0,
+          "type": "integer"
+        },
+        "value": {
+          "const": 0
+        }
+      },
+      "required": [
+        "point_index",
+        "value",
+        "gradient",
+        "multiplicity"
+      ],
+      "type": "object"
+    }
+  },
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "properties": {
+    "claimed_assurance": {
+      "enum": [
+        "UNVERIFIED",
+        "COMPUTED",
+        "CHECKED",
+        "VERIFIED"
+      ]
+    },
+    "completeness": {
+      "const": "COMPLETE"
+    },
+    "conclusion": {
+      "const": "ALGEBRAIC_DIVISOR_CLASS_CERTIFICATE"
+    },
+    "evidence": {
+      "items": {
+        "additionalProperties": false,
+        "properties": {
+          "path": {
+            "const": "evidence/answer.txt"
+          },
+          "sha256": {
+            "pattern": "^sha256:[0-9a-f]{64}$",
+            "type": "string"
+          }
+        },
+        "required": [
+          "path",
+          "sha256"
+        ],
+        "type": "object"
+      },
+      "maxItems": 1,
+      "minItems": 1,
+      "type": "array"
+    },
+    "limitations": {
+      "const": [
+        "ONE_CUBIC_DIVISOR_ON_ONE_BLOWUP",
+        "LEFSCHETZ_1_1_TRUSTED",
+        "NO_HIGHER_CODIMENSION_HODGE_CONCLUSION"
+      ]
+    },
+    "result": {
+      "additionalProperties": false,
+      "properties": {
+        "arithmetic_genus": {
+          "const": 1
+        },
+        "canonical_intersection": {
+          "const": -3
+        },
+        "coefficients": {
+          "items": {
+            "maximum": 20,
+            "minimum": -20,
+            "type": "integer"
+          },
+          "maxItems": 10,
+          "minItems": 10,
+          "type": "array"
+        },
+        "cycle_classification": {
+          "const": "ALGEBRAIC_DIVISOR_HODGE_1_1"
+        },
+        "divisor_class": {
+          "const": [
+            3,
+            -1,
+            -1,
+            -1,
+            -1,
+            -1,
+            -1
+          ]
+        },
+        "point_checks": {
+          "items": {
+            "$ref": "#/$defs/point_check"
+          },
+          "maxItems": 6,
+          "minItems": 6,
+          "type": "array"
+        },
+        "self_intersection": {
+          "const": 3
+        }
+      },
+      "required": [
+        "coefficients",
+        "point_checks",
+        "divisor_class",
+        "self_intersection",
+        "canonical_intersection",
+        "arithmetic_genus",
+        "cycle_classification"
+      ],
+      "type": "object"
+    },
+    "scope": {
+      "const": "six-point-p2-blowup-divisor-v1",
+      "type": "string"
+    },
+    "task_id": {
+      "const": "jacobian/hodge-blowup-divisor-certificate"
+    }
+  },
+  "required": [
+    "task_id",
+    "conclusion",
+    "result",
+    "claimed_assurance",
+    "scope",
+    "completeness",
+    "evidence",
+    "limitations"
+  ],
+  "type": "object"
+}

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/instruction.md

@@ -0,0 +1,32 @@
+# Certify an algebraic divisor class on a six-point blow-up
+
+Submit a nonzero homogeneous cubic over `ZZ`, in the frozen ten-monomial
+order, that vanishes simply at all six frozen points. For each point report the
+polynomial value and three first partial derivatives. At least one derivative
+must be nonzero, certifying multiplicity exactly one.
+
+For the strict-transform divisor class `D=3H-E1-...-E6`, report its class
+vector, `D^2`, `D·K` for `K=-3H+E1+...+E6`, and the adjunction arithmetic
+genus. The verifier recomputes all evaluations and intersection arithmetic.
+
+The coefficients must be primitive (i.e., their GCD must be 1); scalar multiples
+are rejected. Evidence is matching JSON with exactly `schema_version`, `task_id`, `result`,
+and `limitations`. Lefschetz (1,1) is a declared trusted theorem.
+This one divisor certificate does not address higher-codimension Hodge classes
+or prove the Hodge Conjecture.
+
+<!-- BEGIN PUBLIC CONTRACT SUBMISSION BLOCK -->
+## Submission
+
+Exact divisor-class certificate under trusted Lefschetz (1,1); no general Hodge conclusion.
+
+Write `/app/submission.json` to the exact schema in `environment/submission_schema.json`. The submission envelope requires `task_id`, `conclusion`, `result`, `claimed_assurance`, `scope`, `completeness`, `evidence`, and `limitations`.
+
+- **Conclusion:** exactly `ALGEBRAIC_DIVISOR_CLASS_CERTIFICATE`
+- **Assurance:** scoreable values are `UNVERIFIED`, `COMPUTED`, `CHECKED` (ceiling `CHECKED`); the submission schema accepts any of `UNVERIFIED`, `COMPUTED`, `CHECKED`, `VERIFIED` but only scoreable assurances receive credit.
+- **Scope:** the exact value declared in `submission_schema.json`
+- **Completeness:** `COMPLETE`.
+- **Evidence:** 1-1 item(s); allowed path(s): `evidence/answer.txt`; digest must match `^sha256:[0-9a-f]{64}$`.
+- **Evidence media types:** `application/json`.
+- **Required artifact filenames:** `evidence/answer.txt`.
+<!-- END PUBLIC CONTRACT SUBMISSION BLOCK -->

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/solution/solve.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+TASK_ID = "jacobian/hodge-blowup-divisor-certificate"
+LIMITATIONS = [
+    "ONE_CUBIC_DIVISOR_ON_ONE_BLOWUP",
+    "LEFSCHETZ_1_1_TRUSTED",
+    "NO_HIGHER_CODIMENSION_HODGE_CONCLUSION",
+]
+EXP = [
+    (3, 0, 0),
+    (2, 1, 0),
+    (2, 0, 1),
+    (1, 2, 0),
+    (1, 1, 1),
+    (1, 0, 2),
+    (0, 3, 0),
+    (0, 2, 1),
+    (0, 1, 2),
+    (0, 0, 3),
+]
+POINTS = [(0, 0, 1), (1, 0, 1), (0, 1, 1), (1, 1, 1), (2, 0, 1), (0, 2, 1)]
+
+
+def ev(c, p):
+    return sum(
+        v * p[0] ** a * p[1] ** b * p[2] ** d
+        for v, (a, b, d) in zip(c, EXP, strict=True)
+    )
+
+
+def grad(c, p):
+    out = []
+    for axis in range(3):
+        total = 0
+        for v, e in zip(c, EXP, strict=True):
+            if e[axis]:
+                q = list(e)
+                q[axis] -= 1
+                total += v * e[axis] * p[0] ** q[0] * p[1] ** q[1] * p[2] ** q[2]
+        out.append(total)
+    return out
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=Path("/app"))
+    root = parser.parse_args().root
+    c = [1, 0, -3, 0, 0, 2, 1, -3, 2, 0]
+    result = {
+        "coefficients": c,
+        "point_checks": [
+            {
+                "point_index": i,
+                "value": ev(c, p),
+                "gradient": grad(c, p),
+                "multiplicity": 1,
+            }
+            for i, p in enumerate(POINTS)
+        ],
+        "divisor_class": [3, -1, -1, -1, -1, -1, -1],
+        "self_intersection": 3,
+        "canonical_intersection": -3,
+        "arithmetic_genus": 1,
+        "cycle_classification": "ALGEBRAIC_DIVISOR_HODGE_1_1",
+    }
+    payload = {
+        "schema_version": "1",
+        "task_id": TASK_ID,
+        "result": result,
+        "limitations": LIMITATIONS,
+    }
+    e = root / "evidence/answer.txt"
+    e.parent.mkdir(parents=True, exist_ok=True)
+    e.write_text(json.dumps(payload, sort_keys=True, separators=(",", ":")) + "\n")
+    s = {
+        "task_id": TASK_ID,
+        "conclusion": "ALGEBRAIC_DIVISOR_CLASS_CERTIFICATE",
+        "result": result,
+        "claimed_assurance": "CHECKED",
+        "scope": "six-point-p2-blowup-divisor-v1",
+        "completeness": "COMPLETE",
+        "evidence": [
+            {
+                "path": "evidence/answer.txt",
+                "sha256": "sha256:" + hashlib.sha256(e.read_bytes()).hexdigest(),
+            }
+        ],
+        "limitations": LIMITATIONS,
+    }
+    (root / "submission.json").write_text(json.dumps(s, sort_keys=True) + "\n")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -eu
+python /solution/solve.py

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/task.toml

@@ -0,0 +1,39 @@
+schema_version="1.4"
+artifacts=["/app/submission.json","/app/evidence"]
+[task]
+name="jacobian/hodge-blowup-divisor-certificate"
+version="1.0.0"
+description="Construct and replay a cubic divisor class on the blow-up of P2 at six rational points."
+keywords=["hodge","divisors","blowup","intersection-theory","adjunction"]
+[metadata]
+evaluation_kind="conjecture-probe"
+domain="mathematical-sciences"
+primary_domain="geometry-topology"
+field="algebraic-cycles"
+assurance_ceiling="CHECKED"
+answer_visibility="public"
+provenance_class="authored-conjecture-probe"
+fixture_digest="sha256:7aed2472755c817517af313292b09ff011f0cd000b82c6077e8ead0e5b3a9105"
+required_provider="core"
+author_name="Jacobian contributors"
+difficulty="hard"
+category="mathematics"
+tags=["difficulty-provisional","algebraic-geometry","intersection-theory","scope-audit","offline"]
+case_version="conjecture-probes-v1"
+contamination_class="authored-finite-conjecture-probe"
+derivation="Derived from retained spreadsheet row C-039; the cubic and six-point blow-up fixture are authored."
+[agent]
+timeout_sec=600.0
+[verifier]
+timeout_sec=120.0
+environment_mode="separate"
+[environment]
+network_mode="no-network"
+cpus=1
+memory_mb=1024
+storage_mb=4096
+[verifier.environment]
+network_mode="no-network"
+cpus=1
+memory_mb=1024
+storage_mb=4096

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/tests/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
+LABEL jacobian.task="jacobian/hodge-blowup-divisor-certificate" \
+      jacobian.checksum="4d810a82740d05f3014e3bf9f4b61324c65988a60e07cbd4d579b7708585df24"
+RUN python -m pip install --no-cache-dir attrs==26.1.0 jsonschema==4.26.0 jsonschema-specifications==2025.9.1 referencing==0.37.0 rpds-py==2026.6.3 typing-extensions==4.16.0
+COPY input.json public_contract.json test.sh verifier.py verifier_support.py /tests/
+COPY input.json /app/input.json
+RUN chmod +x /tests/test.sh && python -c 'import json; assert json.load(open("/tests/input.json"))["task_id"] == "jacobian/hodge-blowup-divisor-certificate"'

benchmarks/datasets/conjecture-probes-v1/hodge-blowup-divisor-certificate/tests/input.json

@@ -0,0 +1 @@
+{"task_id":"jacobian/hodge-blowup-divisor-certificate","conjecture_id":"C-039","degree":3,"monomial_order":["x^3","x^2y","x^2z","xy^2","xyz","xz^2","y^3","y^2z","yz^2","z^3"],"blowup_points":[[0,0,1],[1,0,1],[0,1,1],[1,1,1],[2,0,1],[0,2,1]],"coefficient_bound":20,"scope":"six-point-p2-blowup-divisor-v1"}