benchmarks: add Littlewood certified finite search

benchmarks/datasets/conjecture-probes-v1/littlewood-certified-finite-search/README.md

@@ -0,0 +1,12 @@
+# Littlewood certified finite search
+
+Assurance task from retained row C-015. Its sole objective is rigorous finite
+Diophantine-approximation search: reconstruct all record minima using exact
+rational square-root enclosures, not floating point. The full 2000-point range
+is independently replayed and the global finite winner must be interval-
+separated from every competitor.
+
+Difficulty is provisional Hard because nearest-integer branches, 80-digit
+rational bounds, complete record logic, and scope calibration must agree.
+Source: <https://mathworld.wolfram.com/LittlewoodConjecture.html>, status
+checked 2026-08-06. No finite outcome is treated as a liminf result.

benchmarks/datasets/conjecture-probes-v1/littlewood-certified-finite-search/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/littlewood-certified-finite-search/environment/input.json

@@ -0,0 +1 @@
+{"task_id":"jacobian/littlewood-certified-finite-search","conjecture_id":"C-015","radicands":[2,3],"n_min":1,"n_max":2000,"sqrt_scale_digits":80,"scope":"sqrt2-sqrt3-n-up-to-2000-v1"}

benchmarks/datasets/conjecture-probes-v1/littlewood-certified-finite-search/environment/submission_schema.json

@@ -0,0 +1,150 @@
+{
+  "$defs": {
+    "rat": {
+      "pattern": "^[0-9]+(?:/[1-9][0-9]*)?$",
+      "type": "string"
+    },
+    "record": {
+      "additionalProperties": false,
+      "properties": {
+        "floors": {
+          "items": {
+            "minimum": 1,
+            "type": "integer"
+          },
+          "maxItems": 2,
+          "minItems": 2,
+          "type": "array"
+        },
+        "lower": {
+          "$ref": "#/$defs/rat"
+        },
+        "n": {
+          "maximum": 2000,
+          "minimum": 1,
+          "type": "integer"
+        },
+        "nearest": {
+          "items": {
+            "minimum": 1,
+            "type": "integer"
+          },
+          "maxItems": 2,
+          "minItems": 2,
+          "type": "array"
+        },
+        "upper": {
+          "$ref": "#/$defs/rat"
+        }
+      },
+      "required": [
+        "n",
+        "floors",
+        "nearest",
+        "lower",
+        "upper"
+      ],
+      "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": "LITTLEWOOD_FINITE_MINIMUM_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_FIXED_QUADRATIC_IRRATIONAL_PAIR",
+        "N_AT_MOST_2000",
+        "NO_LIMINF_OR_LITTLEWOOD_CONCLUSION"
+      ]
+    },
+    "result": {
+      "additionalProperties": false,
+      "properties": {
+        "argmin_n": {
+          "maximum": 2000,
+          "minimum": 1,
+          "type": "integer"
+        },
+        "comparison_status": {
+          "const": "STRICTLY_SEPARATED_INTERVALS"
+        },
+        "minimum_lower": {
+          "$ref": "#/$defs/rat"
+        },
+        "minimum_upper": {
+          "$ref": "#/$defs/rat"
+        },
+        "records": {
+          "items": {
+            "$ref": "#/$defs/record"
+          },
+          "maxItems": 100,
+          "minItems": 2,
+          "type": "array"
+        }
+      },
+      "required": [
+        "records",
+        "argmin_n",
+        "minimum_lower",
+        "minimum_upper",
+        "comparison_status"
+      ],
+      "type": "object"
+    },
+    "scope": {
+      "const": "sqrt2-sqrt3-n-up-to-2000-v1",
+      "type": "string"
+    },
+    "task_id": {
+      "const": "jacobian/littlewood-certified-finite-search"
+    }
+  },
+  "required": [
+    "task_id",
+    "conclusion",
+    "result",
+    "claimed_assurance",
+    "scope",
+    "completeness",
+    "evidence",
+    "limitations"
+  ],
+  "type": "object"
+}

benchmarks/datasets/conjecture-probes-v1/littlewood-certified-finite-search/instruction.md

@@ -0,0 +1,33 @@
+# Certify a finite Littlewood-product minimum
+
+For every integer `1 <= n <= 2000`, consider
+`n ||n sqrt(2)|| ||n sqrt(3)||`. Use rigorous rational lower and upper
+enclosures obtained from the frozen 80-digit integer-square-root scale, never
+floating point. Submit the complete strict record-minimum sequence. Each row
+must include `n`, the two floor values, the two nearest integers, and canonical
+rational lower/upper bounds for the product. Identify the final finite argmin.
+
+The verifier independently reconstructs all 2000 enclosures and the complete
+record sequence. Evidence is a matching JSON object (`application/json`) with
+exactly `schema_version` (the string `"1"`), `task_id`, `result`, and
+`limitations`.
+
+This certifies only the frozen finite range for `(sqrt(2),sqrt(3))`; it does not
+establish a liminf or any case of Littlewood's conjecture.
+
+<!-- BEGIN PUBLIC CONTRACT SUBMISSION BLOCK -->
+## Submission
+
+Rigorous rational interval replay for a finite range only; no Littlewood 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 `LITTLEWOOD_FINITE_MINIMUM_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`.
+- **Evidence payload:** JSON object with exactly `schema_version` (string `"1"`), `task_id`, `result`, and `limitations`.
+- **Required artifact filenames:** `evidence/answer.txt`.
+<!-- END PUBLIC CONTRACT SUBMISSION BLOCK -->

benchmarks/datasets/conjecture-probes-v1/littlewood-certified-finite-search/solution/solve.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from fractions import Fraction
+from math import isqrt
+from pathlib import Path
+
+TASK_ID = "jacobian/littlewood-certified-finite-search"
+LIMITATIONS = [
+    "ONE_FIXED_QUADRATIC_IRRATIONAL_PAIR",
+    "N_AT_MOST_2000",
+    "NO_LIMINF_OR_LITTLEWOOD_CONCLUSION",
+]
+SCALE = 10**80
+
+
+def bounds(d, n):
+    root = isqrt(d * SCALE * SCALE)
+    lo = Fraction(root, SCALE)
+    hi = Fraction(root + 1, SCALE)
+    floor = isqrt(d * n * n)
+    if 4 * d * n * n < (2 * floor + 1) ** 2:
+        return floor, floor, n * lo - floor, n * hi - floor
+    return floor, floor + 1, floor + 1 - n * hi, floor + 1 - n * lo
+
+
+def row(n):
+    a = bounds(2, n)
+    b = bounds(3, n)
+    return {
+        "n": n,
+        "floors": [a[0], b[0]],
+        "nearest": [a[1], b[1]],
+        "lower": str(n * a[2] * b[2]),
+        "upper": str(n * a[3] * b[3]),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=Path("/app"))
+    root = parser.parse_args().root
+    records = []
+    best = None
+    for n in range(1, 2001):
+        current = row(n)
+        if best is None or Fraction(current["upper"]) < Fraction(best["lower"]):
+            records.append(current)
+            best = current
+    result = {
+        "records": records,
+        "argmin_n": best["n"],
+        "minimum_lower": best["lower"],
+        "minimum_upper": best["upper"],
+        "comparison_status": "STRICTLY_SEPARATED_INTERVALS",
+    }
+    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": "LITTLEWOOD_FINITE_MINIMUM_CERTIFICATE",
+        "result": result,
+        "claimed_assurance": "CHECKED",
+        "scope": "sqrt2-sqrt3-n-up-to-2000-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/littlewood-certified-finite-search/solution/solve.sh

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

benchmarks/datasets/conjecture-probes-v1/littlewood-certified-finite-search/task.toml

@@ -0,0 +1,39 @@
+schema_version="1.4"
+artifacts=["/app/submission.json","/app/evidence"]
+[task]
+name="jacobian/littlewood-certified-finite-search"
+version="1.0.0"
+description="Certify a complete finite record-minimum search for n||n sqrt2||||n sqrt3|| using rigorous rational intervals."
+keywords=["littlewood","diophantine-approximation","interval-certificates"]
+[metadata]
+evaluation_kind="conjecture-probe"
+domain="mathematical-sciences"
+primary_domain="number-theory"
+field="diophantine-approximation"
+assurance_ceiling="CHECKED"
+answer_visibility="public"
+provenance_class="authored-conjecture-probe"
+fixture_digest="sha256:2cf9bff59f47bce08ec9e39dde6c8eb7700af3149a01e72003ce91fffedaaee9"
+required_provider="core"
+author_name="Jacobian contributors"
+difficulty="hard"
+category="mathematics"
+tags=["difficulty-provisional","diophantine-approximation","rigorous-intervals","offline"]
+case_version="conjecture-probes-v1"
+contamination_class="authored-finite-conjecture-probe"
+derivation="Derived from retained spreadsheet row C-015; the sqrt(2), sqrt(3), n<=2000 fixture is authored and finite."
+[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/littlewood-certified-finite-search/tests/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
+LABEL jacobian.task="jacobian/littlewood-certified-finite-search" \
+      jacobian.checksum="592a711cf0c3a06c2eb0a86c967320e3928ac394a389bbdc7765f102b0290f62"
+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/littlewood-certified-finite-search"'

benchmarks/datasets/conjecture-probes-v1/littlewood-certified-finite-search/tests/input.json

@@ -0,0 +1 @@
+{"task_id":"jacobian/littlewood-certified-finite-search","conjecture_id":"C-015","radicands":[2,3],"n_min":1,"n_max":2000,"sqrt_scale_digits":80,"scope":"sqrt2-sqrt3-n-up-to-2000-v1"}