Align Zarankiewicz probe contract

Author: Grace Lee Rui Yue

benchmarks/datasets/conjecture-probes-v1/members/zarankiewicz-projective-plane-certificate.toml

@@ -1,7 +1,7 @@
 schema_version="2"
 task_id="zarankiewicz-projective-plane-certificate"
 task_name="jacobian/zarankiewicz-projective-plane-certificate"
-evaluation_kind="regression"
+evaluation_kind="conjecture-probe"
 domain="mathematical-sciences"
 primary_domain="graph-theory"
 field="extremal-combinatorics"

benchmarks/datasets/conjecture-probes-v1/zarankiewicz-projective-plane-certificate/instruction.md

@@ -10,7 +10,7 @@ The verifier reconstructs projective equivalence classes, recomputes every
 dot-product incidence, checks degrees and duplicate-free coverage, exhaustively
 checks all pairs on both sides, and replays the extremal upper bound. For a
 `K_{2,2}`-free bipartite graph with 13 vertices on each side and left degrees
-`d_i`, the 13 right-vertex pairs can be used at most once, so
+`d_i`, the 78 unordered right-vertex pairs can be used at most once, so
 `sum_i binom(d_i,2) <= binom(13,2)`. Convexity then rules out 53 edges, while
 the submitted 52-edge construction attains the bound.
 

benchmarks/datasets/conjecture-probes-v1/zarankiewicz-projective-plane-certificate/task.toml

@@ -6,7 +6,7 @@ version="1.0.0"
 description="Construct and independently certify the sharp K2,2-free 13-by-13 incidence bound."
 keywords=["zarankiewicz","projective-plane","finite-field","extremal-graph-theory"]
 [metadata]
-evaluation_kind="regression"
+evaluation_kind="conjecture-probe"
 domain="mathematical-sciences"
 primary_domain="graph-theory"
 field="extremal-combinatorics"

benchmarks/datasets/conjecture-probes-v1/zarankiewicz-projective-plane-certificate/tests/Dockerfile

@@ -1,6 +1,6 @@
 FROM python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
 LABEL jacobian.task="jacobian/zarankiewicz-projective-plane-certificate" \
-      jacobian.checksum="5229efdc8b61cfa1f124c6d3f364d2148adcaf986282e50e9381fd54c88f7f39"
+      jacobian.checksum="be39f434e8b7d388540dfa1b67cd22f1f4c46ff9d6eb3a35c25c2a7be0ddb44f"
 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

benchmarks/datasets/conjecture-probes-v1/zarankiewicz-projective-plane-certificate/tests/verifier.py

@@ -11,6 +11,7 @@
     evidence_list_is_bound,
     is_regular_bounded_file,
     load_submission,
+    normalize_reward_file,
     read_evidence_json,
     strict_submission_contract,
     workspace_input_is_bound,
@@ -220,6 +221,7 @@ def reward(value: dict[str, float]) -> None:
     path = Path("/logs/verifier")
     path.mkdir(parents=True, exist_ok=True)
     (path / "reward.json").write_text(json.dumps(value, sort_keys=True))
+    normalize_reward_file(path / "reward.json")
 
 
 def main() -> None:

benchmarks/datasets/conjecture-probes-v1/zarankiewicz-projective-plane-certificate/tests/verifier_support.py

@@ -433,10 +433,53 @@ def aggregate_reward(
     "false_verified_claim",
     "is_regular_bounded_file",
     "load_submission",
+    "normalize_reward_file",
     "read_evidence_json",
     "resolve_evidence",
     "sha256_uri",
     "strict_submission_contract",
     "valid_sha256_uri",
     "workspace_input_is_bound",
 ]
+
+
+def normalize_reward_file(reward_path: Path) -> None:
+    """Split a verifier's completed reward payload into scalar and details files."""
+
+    def reject_duplicates(pairs):
+        value = {}
+        for key, item in pairs:
+            if key in value:
+                raise RuntimeError(f"duplicate verifier reward key: {key}")
+            value[key] = item
+        return value
+
+    def reject_constant(value):
+        raise RuntimeError(f"non-finite verifier reward value: {value}")
+
+    payload = json.loads(
+        reward_path.read_text(encoding="utf-8"),
+        object_pairs_hook=reject_duplicates,
+        parse_constant=reject_constant,
+    )
+    if not isinstance(payload, dict):
+        raise RuntimeError("verifier reward payload must be a JSON object")
+    if "reward" not in payload:
+        raise RuntimeError("verifier reward payload is missing reward")
+    reward = payload["reward"]
+    if (
+        isinstance(reward, bool)
+        or not isinstance(reward, (int, float))
+        or reward != reward
+        or abs(reward) == float("inf")
+        or not 0.0 <= reward <= 1.0
+    ):
+        raise RuntimeError("verifier reward must be a finite numeric scalar")
+    details = {key: value for key, value in payload.items() if key != "reward"}
+    (reward_path.parent / "reward-details.json").write_text(
+        json.dumps(details, sort_keys=True, allow_nan=False), encoding="utf-8"
+    )
+    reward_path.write_text(
+        json.dumps({"reward": reward}, sort_keys=True, allow_nan=False),
+        encoding="utf-8",
+    )

benchmarks/validation/conjecture_probes_v1/test_zarankiewicz_projective_plane_certificate.py

@@ -51,56 +51,56 @@ def run(app: Path, logs: Path):
 
 def test_oracle_and_independent_projective_order_pass(tmp_path):
     app, logs, submission = case(tmp_path)
-    assert run(app, logs)["aggregate_reward"] == 1.0
+    assert run(app, logs).details["aggregate_reward"] == 1.0
     permutation = list(reversed(range(13)))
     result = submission["result"]
     result["points"] = [result["points"][i] for i in permutation]
     result["lines"] = [result["lines"][i] for i in permutation]
     inverse = {old: new for new, old in enumerate(permutation)}
     result["edges"] = sorted([[inverse[i], inverse[j]] for i, j in result["edges"]])
     write(app, submission)
-    assert run(app, logs)["aggregate_reward"] == 1.0
+    assert run(app, logs).details["aggregate_reward"] == 1.0
 
 
 def test_missing_and_nonincidence_edges_fail(tmp_path):
     app, logs, submission = case(tmp_path)
     submission["result"]["edges"][-1] = submission["result"]["edges"][0]
     write(app, submission)
-    assert run(app, logs)["aggregate_reward"] == 0.0
+    assert run(app, logs).details["aggregate_reward"] == 0.0
     app, logs, submission = case(tmp_path / "nonincidence")
     submission["result"]["edges"][0] = [0, 0]
     write(app, submission)
-    assert run(app, logs)["mathematics"] == 0.0
+    assert run(app, logs).details["mathematics"] == 0.0
 
 
 def test_bad_projective_normalization_and_pair_count_fail(tmp_path):
     app, logs, submission = case(tmp_path)
     submission["result"]["points"][0] = [2, 0, 0]
     write(app, submission)
-    assert run(app, logs)["mathematics"] == 0.0
+    assert run(app, logs).details["mathematics"] == 0.0
     app, logs, submission = case(tmp_path / "pair")
     submission["result"]["left_pair_common_counts"][0]["common_neighbors"] = 0
     write(app, submission)
-    assert run(app, logs)["aggregate_reward"] == 0.0
+    assert run(app, logs).details["aggregate_reward"] == 0.0
 
 
 def test_false_assurance_and_tampered_evidence_fail(tmp_path):
     app, logs, submission = case(tmp_path)
     submission["claimed_assurance"] = "VERIFIED"
     write(app, submission)
     result = run(app, logs)
-    assert result["mathematics"] == 1.0 and result["assurance"] == 0.0
-    assert result["aggregate_reward"] == 0.0
+    assert result.details["mathematics"] == 1.0 and result.details["assurance"] == 0.0
+    assert result.details["aggregate_reward"] == 0.0
     app, logs, _ = case(tmp_path / "evidence")
     (app / "evidence/answer.txt").write_text("tampered\n")
     result = run(app, logs)
-    assert result["mathematics"] == 1.0 and result["evidence"] == 0.0
-    assert result["aggregate_reward"] == 0.0
+    assert result.details["mathematics"] == 1.0 and result.details["evidence"] == 0.0
+    assert result.details["aggregate_reward"] == 0.0
 
 
 def test_malformed_json_preserves_fail_closed_behavior(tmp_path):
     app, logs, _ = case(tmp_path)
     (app / "submission.json").write_text('{"claimed_assurance": NaN}\n')
     result = run(app, logs)
-    assert result["aggregate_reward"] == 0.0
-    assert result["mathematics"] == 0.0
+    assert result.details["aggregate_reward"] == 0.0
+    assert result.details["mathematics"] == 0.0