Simplify JSON submission workflow

app.py

@@ -32,6 +32,7 @@ DATA_DIR.mkdir(parents=True, exist_ok=True)
 FAVICON_PATH = SPACE_ROOT / "assets" / "favicon.svg"
 HYDRATE_STATUS = maybe_hydrate_from_dataset(DATA_DIR)
 STORE = SolutionStore(DATA_DIR)
+SUBMISSION_MIN_IMPROVEMENT = 1.0e-4
 
 
 @lru_cache(maxsize=1)
@@ -1540,7 +1541,13 @@ Coordinate convention:
 - touching is legal; overlap and protrusion are rejected
 """
 
-EXAMPLES_MD = f"""### Minimal Triangle Example
+EXAMPLES_MD = f"""### How Submission Works
+
+Paste one canonical coordinate JSON object, click **Verify**, then click **Submit Entry** if it passes.
+
+The geometry tolerance is fixed by the evaluator and is not user-selectable. For an existing case, a submission must improve the current top metric by at least `0.0001` to be accepted as a new record. In these tables, smaller metric values are better.
+
+### Minimal Triangle Example
 
 This is the smallest legal record and a good shape for checking the schema:
 
@@ -1554,6 +1561,7 @@ This is the smallest legal record and a good shape for checking the schema:
 - Use container-centered coordinates.
 - Use radians for `rotation_radians`.
 - Click **Verify** before submitting; the preview is rendered from the same canonical JSON that is archived.
+- Existing cases must beat the current top metric by at least `0.0001`.
 """
 
 SCHEMA_DOCS_MD = """### Canonical Fields
@@ -1575,7 +1583,7 @@ Supported shape specs:
 - `circle`: `radius` or `diameter`
 - `rectangle`: `width` and `height`
 
-The verifier rejects boundary protrusion and pair overlap above the selected tolerance.
+The verifier uses a fixed geometry tolerance. Existing cases must improve the current top metric by at least `0.0001` before they can be submitted as records.
 """ + f"""
 
 ### Four Circles In A Square
@@ -2571,32 +2579,76 @@ def submit_schema_intro_html() -> str:
             <div>
               <h2>Submit Entry</h2>
               <p class="section-note">
-                Paste canonical coordinate JSON, verify the geometry, and archive a renderer-ready record.
+                Paste one canonical coordinate JSON object. Existing cases must beat the current top metric by at least 0.0001.
               </p>
             </div>
           </div>
-          <div class="submit-flow" aria-label="Submission steps">
-            <div class="submit-step"><strong>1. Identify</strong><span>Choose a credited author from the searchable list, or type a new name.</span></div>
-            <div class="submit-step"><strong>2. Verify</strong><span>Paste or upload canonical JSON and run the same geometric evaluator used by the leaderboard.</span></div>
-            <div class="submit-step"><strong>3. Submit</strong><span>Accepted records are stored with normalized JSON and rendered directly as vector geometry.</span></div>
-          </div>
         </div>
       </section>
     </main>
     """
 
 
-def load_submission(json_text: str, json_file: str | None) -> dict[str, Any]:
-    if json_file:
-        return load_solution_json(Path(json_file).read_text())
+def load_submission(json_text: str) -> dict[str, Any]:
     if not json_text or not json_text.strip():
-        raise ValueError("Paste canonical JSON or upload a .json file.")
+        raise ValueError("Paste canonical coordinate JSON.")
     return load_solution_json(json_text)
 
 
-def result_markdown(result: dict[str, Any]) -> str:
-    if result["ok"]:
+def record_metric_float(record: dict[str, Any]) -> float | None:
+    value = record.get("metric_value")
+    if value is None:
+        value = record.get("side")
+    try:
+        metric = float(value)
+    except (TypeError, ValueError):
+        return None
+    return metric if math.isfinite(metric) else None
+
+
+def current_top_for_case(case: str) -> dict[str, Any] | None:
+    candidates = [record for record in cached_public_records("", False) if str(record.get("case")) == case]
+    candidates = [record for record in candidates if record_metric_float(record) is not None]
+    if not candidates:
+        return None
+    return min(candidates, key=lambda record: record_metric_float(record) or float("inf"))
+
+
+def submission_gate(result: dict[str, Any]) -> tuple[bool, str]:
+    if not result.get("ok"):
+        return False, "Geometry verification failed."
+    submitted = result.get("side")
+    try:
+        submitted_metric = float(submitted)
+    except (TypeError, ValueError):
+        return False, "The evaluator could not compute a submitted metric."
+    if not math.isfinite(submitted_metric):
+        return False, "The evaluator returned a non-finite metric."
+
+    current = current_top_for_case(str(result.get("case") or ""))
+    if current is None:
+        return True, "No current top record exists for this case; a valid geometry can be submitted."
+
+    current_metric = record_metric_float(current)
+    if current_metric is None:
+        return True, "No comparable current top metric exists; a valid geometry can be submitted."
+
+    improvement = current_metric - submitted_metric
+    if improvement >= SUBMISSION_MIN_IMPROVEMENT:
         return (
+            True,
+            f"Improves the current top metric by {improvement:.10f}; required improvement is at least {SUBMISSION_MIN_IMPROVEMENT:.4f}.",
+        )
+    return (
+        False,
+        f"Current top metric is {current_metric:.10f}. Submitted metric is {submitted_metric:.10f}. "
+        f"Improvement is {improvement:.10f}; required improvement is at least {SUBMISSION_MIN_IMPROVEMENT:.4f}.",
+    )
+
+
+def result_markdown(result: dict[str, Any], gate: tuple[bool, str] | None = None) -> str:
+    if result["ok"]:
+        text = (
             "### Verification Passed\n\n"
             f"- Case: `{result['case']}`\n"
             f"- Items: `{result['n']}`\n"
@@ -2605,12 +2657,17 @@ def result_markdown(result: dict[str, Any]) -> str:
             f"- Max boundary excess: `{result['max_boundary_excess']:.3e}`\n"
             f"- Max pair overlap depth: `{result['max_pair_overlap_depth']:.3e}`\n"
         )
+        if gate is not None:
+            passed, message = gate
+            status = "Passed" if passed else "Needs improvement"
+            text += f"\n### Record Gate\n\n- Status: `{status}`\n- {message}\n"
+        return text
     errors = "\n".join(f"- {e}" for e in result["errors"])
     return "### Verification Failed\n\n" + errors
 
 
 def empty_report_markdown() -> str:
-    return "### Ready To Verify\n\nPaste JSON or upload a file, then run the verifier. Results and geometry diagnostics will appear here."
+    return "### Ready To Verify\n\nPaste canonical JSON, then run the verifier. Existing cases must improve the current top metric by at least `0.0001`."
 
 
 def empty_preview_html() -> str:
@@ -2647,38 +2704,41 @@ def preview_html(solution: dict[str, Any]) -> str:
     """
 
 
-def verify_only(json_text: str, json_file: str | None, tolerance: float):
+def verify_only(json_text: str):
     try:
-        solution = normalize_solution(load_submission(json_text, json_file))
-        result = verify_solution(solution, tolerance=tolerance).as_dict()
+        solution = normalize_solution(load_submission(json_text))
+        result = verify_solution(solution, tolerance=DEFAULT_TOLERANCE).as_dict()
+        gate = submission_gate(result) if result["ok"] else None
         pretty = json.dumps(solution, indent=2, sort_keys=True)
         preview = preview_html(solution) if result["ok"] else ""
-        return result_markdown(result), preview, pretty
+        return result_markdown(result, gate), preview, pretty
     except Exception as exc:
         return f"### Verification Failed\n\n- {exc}", empty_preview_html(), json_text
 
 
 def submit_solution(
     json_text: str,
-    json_file: str | None,
     submitter: str,
     notes: str,
     source_url: str,
-    tolerance: float,
 ):
     try:
-        solution = normalize_solution(load_submission(json_text, json_file))
+        solution = normalize_solution(load_submission(json_text))
+        preflight = verify_solution(solution, tolerance=DEFAULT_TOLERANCE).as_dict()
+        gate_ok, gate_message = submission_gate(preflight)
+        if not gate_ok:
+            return result_markdown(preflight, (gate_ok, gate_message)), preview_html(solution), json.dumps(solution, indent=2, sort_keys=True), gr.update(), gr.update()
         record, result = STORE.append_verified_submission(
             solution,
             submitter=submitter,
             notes=notes,
             source_url=source_url,
-            tolerance=tolerance,
+            tolerance=DEFAULT_TOLERANCE,
         )
         stored = STORE.solution_for_record(record)
         pretty = json.dumps(stored, indent=2, sort_keys=True)
         sync_status = record.get("sync_status", "dataset sync disabled")
-        message = result_markdown(result) + f"\n\nSaved as record `{record['id']}`.\n\nDataset sync: `{sync_status}`."
+        message = result_markdown(result, (gate_ok, gate_message)) + f"\n\nSaved as record `{record['id']}`.\n\nDataset sync: `{sync_status}`."
         clear_page_caches()
         return (
             message,
@@ -2718,24 +2778,23 @@ with gr.Blocks(
             with gr.Row(elem_classes=["submit-layout"]):
                 with gr.Column(scale=7, elem_classes=["submit-editor"]):
                     with gr.Group(elem_classes=["submit-panel"]):
-                        gr.HTML('<div class="submit-panel-title">Canonical Geometry</div>')
-                        gr.HTML('<p class="submit-panel-note">Paste JSON here, or upload a file below. Verification normalizes the payload before archival.</p>')
+                        gr.HTML('<div class="submit-panel-title">Paste JSON</div>')
+                        gr.HTML('<p class="submit-panel-note">Paste one canonical coordinate JSON object. The evaluator uses a fixed tolerance and requires a 0.0001 metric improvement for existing cases.</p>')
                         json_code = gr.Textbox(
                             **supported_gradio_kwargs(
                                 gr.Textbox,
                                 value=SAMPLE_JSON,
                                 label="Coordinate JSON",
-                                lines=20,
+                                lines=18,
                                 max_lines=30,
                                 show_copy_button=True,
                             )
                         )
-                        json_file = gr.File(label="Upload .json", file_types=[".json"], type="filepath")
 
                 with gr.Column(scale=5, elem_classes=["submit-meta"]):
                     with gr.Group(elem_classes=["submit-panel"]):
-                        gr.HTML('<div class="submit-panel-title">Record Details</div>')
-                        gr.HTML('<p class="submit-panel-note">Search past credited authors, or type a new name directly into the same field.</p>')
+                        gr.HTML('<div class="submit-panel-title">Author</div>')
+                        gr.HTML('<p class="submit-panel-note">Choose an existing credited author or type a new name.</p>')
                         submitter = gr.Dropdown(
                             **supported_gradio_kwargs(
                                 gr.Dropdown,
@@ -2747,9 +2806,8 @@ with gr.Blocks(
                                 info="Start typing to search existing authors. New names are accepted.",
                             )
                         )
-                        source_url = gr.Textbox(label="Source URL", placeholder="Optional paper, repo, run log, or note URL")
-                        notes = gr.Textbox(label="Notes", lines=3, placeholder="Optional method, provenance, or contact note")
-                        tolerance = gr.Number(value=DEFAULT_TOLERANCE, label="Verification tolerance")
+                        source_url = gr.Textbox(label="Source URL", placeholder="Optional")
+                        notes = gr.Textbox(label="Notes", lines=3, placeholder="Optional method or provenance note")
                         with gr.Row(elem_classes=["submit-actions"]):
                             verify_btn = gr.Button("Verify", variant="secondary")
                             submit_btn = gr.Button("Submit Entry", variant="primary")
@@ -2776,16 +2834,14 @@ with gr.Blocks(
                             )
 
             with gr.Group(elem_classes=["submit-docs"]):
-                with gr.Accordion("Examples", open=False):
-                    gr.Markdown(EXAMPLES_MD)
-                with gr.Accordion("Schema And Coordinate Rules", open=False):
-                    gr.Markdown(SCHEMA_DOCS_MD)
+                with gr.Accordion("Submission Documentation", open=False):
+                    gr.Markdown(EXAMPLES_MD + "\n\n" + SCHEMA_DOCS_MD)
 
     demo.load(home_page_for_request, outputs=[browse_page], show_progress="hidden")
-    verify_btn.click(verify_only, inputs=[json_code, json_file, tolerance], outputs=[report, preview, normalized_json])
+    verify_btn.click(verify_only, inputs=[json_code], outputs=[report, preview, normalized_json])
     submit_btn.click(
         submit_solution,
-        inputs=[json_code, json_file, submitter, notes, source_url, tolerance],
+        inputs=[json_code, submitter, notes, source_url],
         outputs=[report, preview, normalized_json, leaderboard_page, submitter],
     )