Add record dates, recent markers, previous bests, and integrity stamps

app.py

@@ -12,6 +12,13 @@ from typing import Any
 
 import gradio as gr
 
+from packing_benchmark.dates import (
+    date_from_friedman_record,
+    date_from_submission,
+    display_date_info,
+    is_recent_date_info,
+    parse_friedman_date_text,
+)
 from packing_benchmark.hub_sync import maybe_hydrate_from_dataset
 from packing_benchmark.store import SolutionStore, is_trivial_record, metric_matches_reference
 from packing_benchmark.verifier import (
@@ -45,6 +52,19 @@ def cached_verified_records() -> list[dict[str, Any]]:
     return STORE.load_records()
 
 
+@lru_cache(maxsize=1)
+def cached_family_updates() -> dict[str, Any]:
+    path = DATA_DIR / "friedman_family_updates.json"
+    if not path.exists():
+        return {}
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return {}
+    families = payload.get("families", {})
+    return families if isinstance(families, dict) else {}
+
+
 @lru_cache(maxsize=64)
 def cached_public_records(setup: str = "", show_all: bool = False) -> list[dict[str, Any]]:
     return STORE.public_records(setup or None, show_all=show_all)
@@ -53,6 +73,7 @@ def cached_public_records(setup: str = "", show_all: bool = False) -> list[dict[
 def clear_page_caches() -> None:
     cached_reference_records.cache_clear()
     cached_verified_records.cache_clear()
+    cached_family_updates.cache_clear()
     cached_public_records.cache_clear()
     setup_choices.cache_clear()
     coordinate_records_by_case.cache_clear()
@@ -451,6 +472,23 @@ footer,
   font-weight: 700;
 }
 
+.recent-dot {
+  display: inline-block;
+  width: 9px;
+  height: 9px;
+  margin-left: 7px;
+  background: var(--green-strong);
+  border: 1px solid #174c1b;
+  border-radius: 999px;
+  vertical-align: 1px;
+}
+
+.family-card h3 .recent-dot {
+  width: 10px;
+  height: 10px;
+  vertical-align: 2px;
+}
+
 .render-stage {
   height: 178px;
   margin: 8px 10px 0;
@@ -738,6 +776,32 @@ footer,
   color: var(--link) !important;
 }
 
+.previous-bests-table {
+  width: 100%;
+  border-collapse: collapse;
+  background: var(--paper) !important;
+  color: var(--ink) !important;
+  font-size: 12px;
+}
+
+.previous-bests-table th,
+.previous-bests-table td {
+  padding: 6px 7px;
+  border: 1px solid var(--line-soft);
+  color: var(--ink) !important;
+  text-align: left;
+  vertical-align: top;
+}
+
+.previous-bests-table th {
+  background: var(--paper-soft) !important;
+  font-weight: 700;
+}
+
+.date-source {
+  color: var(--muted) !important;
+}
+
 .record-modal .modal-panel .modal-case {
   color: var(--quiet) !important;
 }
@@ -1670,13 +1734,22 @@ def submission_guide_html() -> str:
 
 def setup_title(setup: str) -> str:
     for record in cached_reference_records():
+        if record.get("_integrity_errors"):
+            continue
         if record.get("setup") == setup and record.get("title"):
             return str(record["title"])
     return setup
 
 
 def setup_updated(setup: str) -> str:
+    update = cached_family_updates().get(setup)
+    if isinstance(update, dict):
+        text = str(update.get("text") or "").strip()
+        if text:
+            return text
     for record in cached_reference_records():
+        if record.get("_integrity_errors"):
+            continue
         if record.get("setup") != setup:
             continue
         meta = record.get("friedman_reference")
@@ -1687,17 +1760,25 @@ def setup_updated(setup: str) -> str:
     return ""
 
 
+def setup_update_date_info(setup: str) -> dict[str, Any] | None:
+    update = cached_family_updates().get(setup)
+    if isinstance(update, dict):
+        return update
+    updated = setup_updated(setup)
+    return parse_friedman_date_text(updated, "Erich Friedman Packing Center index") if updated else None
+
+
 @lru_cache(maxsize=96)
 def setup_choices() -> list[str]:
     choices = {
         str(record["setup"])
         for record in cached_reference_records()
-        if record.get("setup")
+        if record.get("setup") and not record.get("_integrity_errors")
     }
     choices.update(
         str(record["setup"])
         for record in cached_verified_records()
-        if record.get("verified") and record.get("setup")
+        if record.get("verified") and record.get("setup") and not record.get("_integrity_errors")
     )
     return sorted(choices, key=lambda setup: (setup_title(setup).lower(), setup.lower()))
 
@@ -1710,21 +1791,30 @@ def is_analytical(record: dict[str, Any]) -> bool:
     return any(token in text for token in proof_tokens) or any(token in expression.lower() for token in exact_tokens)
 
 
+def effective_record_date(record: dict[str, Any]) -> dict[str, Any]:
+    info = record.get("record_date")
+    if isinstance(info, dict):
+        return info
+    if record.get("record_type") == "reference" or record.get("frontend_seed") or is_trivial_record(record):
+        return date_from_friedman_record(record)
+    return date_from_submission(record)
+
+
 def display_date(record: dict[str, Any]) -> str:
-    submitted_at = str(record.get("submitted_at") or "").strip()
-    if submitted_at:
-        try:
-            parsed = datetime.fromisoformat(submitted_at.replace("Z", "+00:00"))
-            return parsed.strftime("%b %-d, %Y")
-        except ValueError:
-            return submitted_at
+    return display_date_info(effective_record_date(record))
+
+
+def record_date_with_source(record: dict[str, Any]) -> str:
+    info = effective_record_date(record)
+    text = display_date_info(info)
+    source = str(info.get("source") or "").strip() if isinstance(info, dict) else ""
+    if source and text != "date not listed":
+        return f"{esc(text)} <span class=\"date-source\">({esc(source)})</span>"
+    return esc(text)
+
 
-    text = str(record.get("reference_text") or "")
-    month_pattern = "|".join(MONTHS)
-    match = re.search(rf"\bin\s+((?:{month_pattern})\s+\d{{4}}|\d{{4}})\b", text)
-    if match:
-        return match.group(1)
-    return "date not listed"
+def is_recent_record(record: dict[str, Any]) -> bool:
+    return is_recent_date_info(effective_record_date(record))
 
 
 def friedman_reference(record: dict[str, Any]) -> dict[str, Any]:
@@ -1793,6 +1883,8 @@ def author_credit_html(author: str) -> str:
 def existing_author_choices() -> list[str]:
     seen: dict[str, str] = {}
     for record in [*cached_reference_records(), *cached_verified_records()]:
+        if record.get("_integrity_errors"):
+            continue
         name = display_author(record)
         normalized = name.strip()
         if not normalized or normalized.lower() in {"unknown", "anonymous"}:
@@ -1956,6 +2048,57 @@ def detail_row(label: str, value: str) -> str:
     return f"<dt>{esc(label)}</dt><dd>{value}</dd>"
 
 
+def metric_text_from_values(symbol: Any, value: Any) -> str:
+    try:
+        return f"{esc(symbol or 's')} = {float(value):.5f}"
+    except (TypeError, ValueError):
+        return f"{esc(symbol or 's')} = {esc(value)}"
+
+
+def previous_bests_table(record: dict[str, Any]) -> str:
+    previous = record.get("previous_bests")
+    if not isinstance(previous, list) or not previous:
+        return ""
+    rows = []
+    for item in previous:
+        if not isinstance(item, dict):
+            continue
+        date_info = item.get("date")
+        date_text = display_date_info(date_info if isinstance(date_info, dict) else None)
+        source_url = str(item.get("source_url") or "").strip()
+        source = str(item.get("source") or "previous record").strip()
+        source_cell = f'<a href="{esc(source_url)}" target="_blank" rel="noopener noreferrer">{esc(source)}</a>' if source_url else esc(source)
+        rows.append(
+            "<tr>"
+            f"<td>{esc(item.get('author') or 'unknown')}</td>"
+            f"<td>{esc(date_text)}</td>"
+            f"<td>{metric_text_from_values(item.get('metric_symbol') or metric_symbol(record), item.get('metric_value'))}</td>"
+            f"<td>{source_cell}</td>"
+            "</tr>"
+        )
+    if not rows:
+        return ""
+    return (
+        '<table class="previous-bests-table">'
+        "<thead><tr><th>Author</th><th>Date</th><th>Metric</th><th>Source</th></tr></thead>"
+        f"<tbody>{''.join(rows)}</tbody></table>"
+    )
+
+
+def integrity_status_text(record: dict[str, Any], visual_record: dict[str, Any]) -> str:
+    errors = list(record.get("_integrity_errors") or [])
+    if visual_record is not record:
+        errors.extend(list(visual_record.get("_integrity_errors") or []))
+    if errors:
+        return "failed: " + "; ".join(esc(error) for error in errors)
+    integrity = record.get("integrity") or visual_record.get("integrity")
+    if isinstance(integrity, dict) and integrity.get("signature"):
+        return "verified with signed record and solution hashes"
+    if isinstance(integrity, dict):
+        return "verified with record and solution hashes"
+    return "legacy row; no integrity stamp"
+
+
 def visual_provenance(record: dict[str, Any], visual_record: dict[str, Any]) -> str:
     source_case = str(visual_record.get("monotone_upper_bound_from_case") or "").strip()
     if source_case:
@@ -2008,6 +2151,8 @@ def needs_recovery(record: dict[str, Any], visual_record: dict[str, Any]) -> boo
 def record_detail_rows(record: dict[str, Any], visual_record: dict[str, Any], source: str, image_name: str, expression: str, analytical: Any) -> list[str]:
     rows: list[str] = []
     rows.append(detail_row("Rendering", esc(visual_provenance(record, visual_record))))
+    rows.append(detail_row("Record date", record_date_with_source(record)))
+    rows.append(detail_row("Database integrity", esc(integrity_status_text(record, visual_record))))
     if record.get("record_type") == "reference" and visual_record.get("verified"):
         if is_trivial_record(record):
             rows.append(
@@ -2030,19 +2175,13 @@ def record_detail_rows(record: dict[str, Any], visual_record: dict[str, Any], so
             )
         )
     if record.get("record_type") == "verified":
-        rows.append(detail_row("Submitted", esc(display_date(record))))
+        database_inserted_at = str(record.get("database_inserted_at") or record.get("submitted_at") or "").strip()
+        database_info = date_from_submission({"submitted_at": database_inserted_at})
+        rows.append(detail_row("Database entry", esc(display_date_info(database_info))))
         notes = str(record.get("notes") or "").strip()
         if notes:
             rows.append(detail_row("Notes", esc(notes)))
-        previous = (
-            f"{esc(metric_symbol(record))} = {esc(metric_value({'metric_value': record.get('reference_side'), 'side': record.get('reference_side'), 'metric_symbol': metric_symbol(record)}))}"
-            f" by {esc(reference_credit(record))}, {esc(reference_date(record))}"
-            if record.get("reference_side") is not None
-            else ""
-        )
-        rows.append(detail_row("Previous record", previous))
-    else:
-        rows.append(detail_row("Date", esc(reference_date(record))))
+        rows.append(detail_row("Previous bests", previous_bests_table(record)))
 
     rows.append(detail_row("Formula", esc(expression)))
     if image_name:
@@ -2107,13 +2246,16 @@ def record_card(record: dict[str, Any], coordinates: dict[str, dict[str, Any]])
     card_class = "verified" if verified else "reference"
     if needs_recovery(record, visual_record):
         card_class += " needs-recovery"
+    if is_recent_record(record):
+        card_class += " recent-record"
+    recent = '<span class="recent-dot" title="New in the last 7 days"></span>' if is_recent_record(record) else ""
     anchor = f"{record.get('setup')}-{record.get('n')}"
     modal_id = f"modal-{anchor}"
     return f"""
     <article class="record-card {card_class}" id="{esc(anchor)}">
       <a class="record-open" href="#{esc(modal_id)}" aria-label="Open {esc(record.get("case"))} record information">
         <div class="record-top">
-          <div class="record-case">{esc(record.get("case"))}</div>
+          <div class="record-case">{esc(record.get("case"))}{recent}</div>
         </div>
         {record_visual(record, coordinates)}
         <div class="record-body">
@@ -2144,6 +2286,7 @@ def setup_summary(setup: str) -> dict[str, Any]:
         "coordinate_count": coordinate_count,
         "analytic": sum(1 for r in records if is_analytical(r)),
         "updated": setup_updated(setup),
+        "updated_recent": is_recent_date_info(setup_update_date_info(setup)),
         "n_range": f"{min(n_values)}-{max(n_values)}" if n_values else "not listed",
     }
 
@@ -2225,13 +2368,14 @@ def family_preview(setup: str, coordinates: dict[str, dict[str, Any]]) -> str:
 def family_card(summary: dict[str, Any], coordinates: dict[str, dict[str, Any]]) -> str:
     setup = str(summary["setup"])
     cls = inner_class(setup)
+    recent = '<span class="recent-dot" title="Updated in the last 7 days"></span>' if summary.get("updated_recent") else ""
     return f"""
     <a class="family-card front-family-card {esc(cls)}" href="?family={esc(setup)}" aria-label="Open {esc(summary["title"])} records">
       {family_preview(setup, coordinates)}
       <div class="family-card-top">
         <div>
           <div class="family-code">{esc(setup)}</div>
-          <h3>{esc(summary["title"])}</h3>
+          <h3>{esc(summary["title"])}{recent}</h3>
         </div>
       </div>
     </a>
@@ -2624,18 +2768,24 @@ def current_top_for_case(case: str) -> dict[str, Any] | 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")
+def submitted_metric_for_result(result: dict[str, Any], current: dict[str, Any] | None) -> tuple[str, float | None]:
     try:
-        submitted_metric = float(submitted)
+        side = float(result.get("side"))
     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."
+        return "s", None
+    if not math.isfinite(side):
+        return "s", None
+    symbol = str((current or {}).get("metric_symbol") or "s")
+    return symbol, side * 0.5 if symbol == "r" else side
+
 
+def submission_gate(result: dict[str, Any]) -> tuple[bool, str]:
+    if not result.get("ok"):
+        return False, "Geometry verification failed."
     current = current_top_for_case(str(result.get("case") or ""))
+    symbol, submitted_metric = submitted_metric_for_result(result, current)
+    if submitted_metric is None:
+        return False, "The evaluator could not compute a submitted metric."
     if current is None:
         return True, "No current top record exists for this case; a valid geometry can be submitted."
 
@@ -2647,11 +2797,11 @@ def submission_gate(result: dict[str, Any]) -> tuple[bool, str]:
     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}.",
+            f"Improves the current top {symbol} 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"Current top {symbol} metric is {current_metric:.10f}. Submitted {symbol} metric is {submitted_metric:.10f}. "
         f"Improvement is {improvement:.10f}; required improvement is at least {SUBMISSION_MIN_IMPROVEMENT:.4f}.",
     )
 

data/friedman_family_updates.json

@@ -0,0 +1,296 @@
+{
+  "families": {
+    "cirincir": {
+      "precision": "day",
+      "raw": "6/30/11",
+      "setup": "cirincir",
+      "sort_date": "2011-06-30",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Jun 30, 2011",
+      "title": "Circles in Circles"
+    },
+    "cirinhex": {
+      "precision": "day",
+      "raw": "7/19/12",
+      "setup": "cirinhex",
+      "sort_date": "2012-07-19",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Jul 19, 2012",
+      "title": "Circles in Hexagons"
+    },
+    "cirinpen": {
+      "precision": "day",
+      "raw": "7/10/12",
+      "setup": "cirinpen",
+      "sort_date": "2012-07-10",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Jul 10, 2012",
+      "title": "Circles in Pentagons"
+    },
+    "cirinsqu": {
+      "precision": "day",
+      "raw": "2/11/26",
+      "setup": "cirinsqu",
+      "sort_date": "2026-02-11",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Feb 11, 2026",
+      "title": "Circles in Squares"
+    },
+    "cirintri": {
+      "precision": "day",
+      "raw": "7/4/11",
+      "setup": "cirintri",
+      "sort_date": "2011-07-04",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Jul 4, 2011",
+      "title": "Circles in Triangles"
+    },
+    "domindom": {
+      "precision": "day",
+      "raw": "4/3/26",
+      "setup": "domindom",
+      "sort_date": "2026-04-03",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 3, 2026",
+      "title": "Dominoes in Dominoes"
+    },
+    "domintri": {
+      "precision": "day",
+      "raw": "4/23/26",
+      "setup": "domintri",
+      "sort_date": "2026-04-23",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 23, 2026",
+      "title": "Dominoes in Triangles"
+    },
+    "hexincir": {
+      "precision": "day",
+      "raw": "4/28/26",
+      "setup": "hexincir",
+      "sort_date": "2026-04-28",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 28, 2026",
+      "title": "Hexagons in Circles"
+    },
+    "hexindom": {
+      "precision": "day",
+      "raw": "4/6/26",
+      "setup": "hexindom",
+      "sort_date": "2026-04-06",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 6, 2026",
+      "title": "Hexagons in Dominoes"
+    },
+    "hexinhex": {
+      "precision": "day",
+      "raw": "4/15/26",
+      "setup": "hexinhex",
+      "sort_date": "2026-04-15",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 15, 2026",
+      "title": "Hexagons in Hexagons"
+    },
+    "hexinsqu": {
+      "precision": "day",
+      "raw": "4/28/26",
+      "setup": "hexinsqu",
+      "sort_date": "2026-04-28",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 28, 2026",
+      "title": "Hexagons in Squares"
+    },
+    "hexintri": {
+      "precision": "day",
+      "raw": "5/1/26",
+      "setup": "hexintri",
+      "sort_date": "2026-05-01",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "May 1, 2026",
+      "title": "Hexagons in Triangles"
+    },
+    "octinoct": {
+      "precision": "day",
+      "raw": "3/27/26",
+      "setup": "octinoct",
+      "sort_date": "2026-03-27",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Mar 27, 2026",
+      "title": "Octagons in Octagons"
+    },
+    "penincir": {
+      "precision": "day",
+      "raw": "4/13/26",
+      "setup": "penincir",
+      "sort_date": "2026-04-13",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 13, 2026",
+      "title": "Pentagons in Circles"
+    },
+    "peninpen": {
+      "precision": "day",
+      "raw": "4/29/26",
+      "setup": "peninpen",
+      "sort_date": "2026-04-29",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 29, 2026",
+      "title": "Pentagons in Pentagons"
+    },
+    "peninsqu": {
+      "precision": "day",
+      "raw": "4/30/26",
+      "setup": "peninsqu",
+      "sort_date": "2026-04-30",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 30, 2026",
+      "title": "Pentagons in Squares"
+    },
+    "squincir": {
+      "precision": "day",
+      "raw": "8/9/11",
+      "setup": "squincir",
+      "sort_date": "2011-08-09",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Aug 9, 2011",
+      "title": "Squares in Circles"
+    },
+    "squindom": {
+      "precision": "day",
+      "raw": "8/11/12",
+      "setup": "squindom",
+      "sort_date": "2012-08-11",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Aug 11, 2012",
+      "title": "Squares in Dominoes"
+    },
+    "squinhex": {
+      "precision": "day",
+      "raw": "5/1/26",
+      "setup": "squinhex",
+      "sort_date": "2026-05-01",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "May 1, 2026",
+      "title": "Squares in Hexagons"
+    },
+    "squinoct": {
+      "precision": "day",
+      "raw": "3/17/26",
+      "setup": "squinoct",
+      "sort_date": "2026-03-17",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Mar 17, 2026",
+      "title": "Squares in Octagons"
+    },
+    "squinpen": {
+      "precision": "day",
+      "raw": "4/30/26",
+      "setup": "squinpen",
+      "sort_date": "2026-04-30",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 30, 2026",
+      "title": "Squares in Pentagons"
+    },
+    "squintri": {
+      "precision": "day",
+      "raw": "4/30/26",
+      "setup": "squintri",
+      "sort_date": "2026-04-30",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 30, 2026",
+      "title": "Squares in Triangles"
+    },
+    "triincir": {
+      "precision": "day",
+      "raw": "8/31/19",
+      "setup": "triincir",
+      "sort_date": "2019-08-31",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Aug 31, 2019",
+      "title": "Triangles in Circles"
+    },
+    "triindom": {
+      "precision": "day",
+      "raw": "4/4/26",
+      "setup": "triindom",
+      "sort_date": "2026-04-04",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 4, 2026",
+      "title": "Triangles in Dominoes"
+    },
+    "triinhex": {
+      "precision": "day",
+      "raw": "4/30/26",
+      "setup": "triinhex",
+      "sort_date": "2026-04-30",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 30, 2026",
+      "title": "Triangles in Hexagons"
+    },
+    "triinoct": {
+      "precision": "day",
+      "raw": "3/22/26",
+      "setup": "triinoct",
+      "sort_date": "2026-03-22",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Mar 22, 2026",
+      "title": "Triangles in Octagons"
+    },
+    "triinpen": {
+      "precision": "day",
+      "raw": "4/30/26",
+      "setup": "triinpen",
+      "sort_date": "2026-04-30",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 30, 2026",
+      "title": "Triangles in Pentagons"
+    },
+    "triinsqu": {
+      "precision": "day",
+      "raw": "5/1/26",
+      "setup": "triinsqu",
+      "sort_date": "2026-05-01",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "May 1, 2026",
+      "title": "Triangles in Squares"
+    },
+    "triintri": {
+      "precision": "day",
+      "raw": "4/30/26",
+      "setup": "triintri",
+      "sort_date": "2026-04-30",
+      "source": "Erich Friedman Packing Center index",
+      "source_url": "https://erich-friedman.github.io/packing/index.html",
+      "text": "Apr 30, 2026",
+      "title": "Triangles in Triangles"
+    }
+  },
+  "retrieved_at": "2026-05-01T21:37:50+00:00",
+  "source_url": "https://erich-friedman.github.io/packing/index.html"
+}

packing_benchmark/dates.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import re
+from datetime import UTC, date, datetime, timedelta
+from typing import Any
+
+
+MONTHS = (
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+)
+
+MONTH_BY_NAME = {name: index + 1 for index, name in enumerate(MONTHS)}
+
+
+def unknown_date(source: str = "") -> dict[str, str]:
+    return {
+        "text": "date not listed",
+        "sort_date": "",
+        "precision": "unknown",
+        "source": source,
+    }
+
+
+def date_info(text: str, sort_date: str, precision: str, source: str) -> dict[str, str]:
+    return {
+        "text": text,
+        "sort_date": sort_date,
+        "precision": precision,
+        "source": source,
+    }
+
+
+def parse_iso_datetime(value: str, source: str = "server submission") -> dict[str, str] | None:
+    value = str(value or "").strip()
+    if not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    parsed = parsed.astimezone(UTC)
+    return date_info(
+        parsed.strftime("%b %-d, %Y"),
+        parsed.date().isoformat(),
+        "second",
+        source,
+    )
+
+
+def parse_friedman_date_text(value: str, source: str = "Erich Friedman Packing Center") -> dict[str, str] | None:
+    value = str(value or "").strip()
+    if not value:
+        return None
+
+    slash = re.fullmatch(r"(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})", value)
+    if slash:
+        month = int(slash.group(1))
+        day = int(slash.group(2))
+        year = int(slash.group(3))
+        if year < 100:
+            year += 2000 if year <= 69 else 1900
+        try:
+            parsed = date(year, month, day)
+        except ValueError:
+            return None
+        return date_info(parsed.strftime("%b %-d, %Y"), parsed.isoformat(), "day", source)
+
+    month_pattern = "|".join(MONTHS)
+    match = re.search(rf"\b((?:{month_pattern})\s+\d{{4}}|\d{{4}})\b", value)
+    if not match:
+        return None
+    text = match.group(1)
+    parts = text.split()
+    if len(parts) == 2:
+        month = MONTH_BY_NAME[parts[0]]
+        year = int(parts[1])
+        return date_info(text, f"{year:04d}-{month:02d}-01", "month", source)
+    year = int(parts[0])
+    return date_info(text, f"{year:04d}-01-01", "year", source)
+
+
+def date_from_reference_text(reference_text: str, source: str = "Erich Friedman Packing Center") -> dict[str, str]:
+    reference_text = str(reference_text or "")
+    month_pattern = "|".join(MONTHS)
+    match = re.search(rf"\bin\s+((?:{month_pattern})\s+\d{{4}}|\d{{4}})\b", reference_text)
+    if match:
+        parsed = parse_friedman_date_text(match.group(1), source)
+        if parsed:
+            return parsed
+    return unknown_date(source)
+
+
+def date_from_friedman_record(record: dict[str, Any], source: str = "Erich Friedman Packing Center") -> dict[str, str]:
+    meta = record.get("friedman_reference")
+    if isinstance(meta, dict):
+        parsed = parse_friedman_date_text(str(meta.get("date") or ""), source)
+        if parsed:
+            return parsed
+        reference_text = str(meta.get("reference_text") or "")
+        if reference_text:
+            return date_from_reference_text(reference_text, source)
+    parsed = parse_friedman_date_text(str(record.get("friedman_date") or record.get("date") or ""), source)
+    if parsed:
+        return parsed
+    return date_from_reference_text(str(record.get("reference_text") or record.get("friedman_reference_text") or ""), source)
+
+
+def date_from_submission(record: dict[str, Any]) -> dict[str, str]:
+    return parse_iso_datetime(str(record.get("submitted_at") or ""), "server submission") or unknown_date("server submission")
+
+
+def display_date_info(info: dict[str, Any] | None) -> str:
+    if not isinstance(info, dict):
+        return "date not listed"
+    return str(info.get("text") or "date not listed")
+
+
+def is_recent_date_info(info: dict[str, Any] | None, *, now: date | None = None, days: int = 7) -> bool:
+    if not isinstance(info, dict):
+        return False
+    if info.get("precision") not in {"day", "second"}:
+        return False
+    sort_date = str(info.get("sort_date") or "")
+    if not sort_date:
+        return False
+    try:
+        parsed = date.fromisoformat(sort_date)
+    except ValueError:
+        return False
+    today = now or datetime.now(UTC).date()
+    return today - timedelta(days=days) <= parsed <= today

packing_benchmark/integrity.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import copy
+import hashlib
+import hmac
+import json
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+
+INTEGRITY_VERSION = 1
+INTEGRITY_KEY_ENV = "PACKING_INTEGRITY_SECRET"
+INTEGRITY_FIELD = "integrity"
+PRIVATE_PREFIX = "_"
+
+
+def canonical_json(payload: Any) -> str:
+    return json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def sha256_text(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def integrity_secret() -> str:
+    return os.environ.get(INTEGRITY_KEY_ENV, "")
+
+
+def record_payload(record: dict[str, Any]) -> dict[str, Any]:
+    payload = copy.deepcopy(record)
+    payload.pop(INTEGRITY_FIELD, None)
+    for key in list(payload):
+        if key.startswith(PRIVATE_PREFIX) or key == "sync_status":
+            payload.pop(key, None)
+    return payload
+
+
+def record_sha256(record: dict[str, Any]) -> str:
+    return sha256_text(canonical_json(record_payload(record)))
+
+
+def _abs_data_path(data_root: Path, path: str | Path) -> Path:
+    p = Path(path)
+    return p if p.is_absolute() else data_root.parent / p
+
+
+def solution_sha256(record: dict[str, Any], data_root: Path) -> str:
+    path = record.get("solution_path")
+    if not path:
+        return ""
+    target = _abs_data_path(data_root, str(path))
+    if not target.exists():
+        return ""
+    return sha256_file(target)
+
+
+def sign_record_digest(record_digest: str, solution_digest: str) -> str:
+    secret = integrity_secret()
+    if not secret:
+        return ""
+    message = f"{record_digest}:{solution_digest}".encode("utf-8")
+    return hmac.new(secret.encode("utf-8"), message, hashlib.sha256).hexdigest()
+
+
+def seal_record(record: dict[str, Any], data_root: Path, *, signed_at: str | None = None) -> dict[str, Any]:
+    out = copy.deepcopy(record)
+    previous = out.get(INTEGRITY_FIELD)
+    record_digest = record_sha256(out)
+    solution_digest = solution_sha256(out, data_root)
+    signature = sign_record_digest(record_digest, solution_digest)
+    if not signature and isinstance(previous, dict) and previous.get("record_sha256") == record_digest:
+        signature = str(previous.get("signature") or "")
+    out[INTEGRITY_FIELD] = {
+        "version": INTEGRITY_VERSION,
+        "record_sha256": record_digest,
+        "solution_sha256": solution_digest,
+        "signature": signature,
+        "signed_at": signed_at or datetime.now(UTC).isoformat(timespec="seconds"),
+    }
+    return out
+
+
+def verify_record_integrity(record: dict[str, Any], data_root: Path) -> list[str]:
+    integrity = record.get(INTEGRITY_FIELD)
+    if not isinstance(integrity, dict):
+        return ["missing integrity stamp"]
+
+    errors: list[str] = []
+    expected_record = record_sha256(record)
+    stored_record = str(integrity.get("record_sha256") or "")
+    if stored_record != expected_record:
+        errors.append("record hash mismatch")
+
+    expected_solution = solution_sha256(record, data_root)
+    stored_solution = str(integrity.get("solution_sha256") or "")
+    if expected_solution != stored_solution:
+        errors.append("solution file hash mismatch")
+
+    secret = integrity_secret()
+    stored_signature = str(integrity.get("signature") or "")
+    if secret:
+        expected_signature = sign_record_digest(stored_record, stored_solution)
+        if not stored_signature or not hmac.compare_digest(stored_signature, expected_signature):
+            errors.append("record signature mismatch")
+    return errors
+
+
+def attach_integrity_status(record: dict[str, Any], data_root: Path) -> dict[str, Any]:
+    out = dict(record)
+    errors = verify_record_integrity(out, data_root)
+    out["_integrity_errors"] = errors
+    out["_integrity_ok"] = not errors
+    return out

packing_benchmark/store.py

@@ -7,7 +7,9 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
+from .dates import date_from_friedman_record, date_from_submission
 from .hub_sync import maybe_sync_dataset
+from .integrity import attach_integrity_status, seal_record
 from .renderer import svg_markup
 from .verifier import (
     DEFAULT_TOLERANCE,
@@ -61,6 +63,14 @@ def is_trivial_record(record: dict[str, Any]) -> bool:
     return credit == "trivial" or "trivial" in text
 
 
+def clean_record_for_storage(record: dict[str, Any]) -> dict[str, Any]:
+    return {
+        key: value
+        for key, value in record.items()
+        if not key.startswith("_") and key != "sync_status"
+    }
+
+
 class SolutionStore:
     def __init__(self, root: Path):
         self.root = root
@@ -85,7 +95,7 @@ class SolutionStore:
         with self.records_path.open() as f:
             for line in f:
                 if line.strip():
-                    records.append(json.loads(line))
+                    records.append(attach_integrity_status(json.loads(line), self.root))
         return records
 
     def load_reference_records(self) -> list[dict[str, Any]]:
@@ -95,7 +105,7 @@ class SolutionStore:
         with self.references_path.open() as f:
             for line in f:
                 if line.strip():
-                    records.append(json.loads(line))
+                    records.append(attach_integrity_status(json.loads(line), self.root))
         return records
 
     def normalized_public_record(self, record: dict[str, Any]) -> dict[str, Any]:
@@ -113,11 +123,15 @@ class SolutionStore:
         return out
 
     def public_records(self, setup: str | None = None, show_all: bool = False) -> list[dict[str, Any]]:
-        references = [self.normalized_public_record(r) for r in self.load_reference_records()]
+        references = [
+            self.normalized_public_record(r)
+            for r in self.load_reference_records()
+            if not r.get("_integrity_errors")
+        ]
         verified = [
             self.normalized_public_record(r)
             for r in self.load_records()
-            if r.get("verified")
+            if r.get("verified") and not r.get("_integrity_errors")
         ]
         if setup and setup != "All":
             references = [r for r in references if r.get("setup") == setup]
@@ -170,9 +184,11 @@ class SolutionStore:
 
     def write_records(self, records: list[dict[str, Any]]) -> None:
         tmp = self.records_path.with_suffix(".tmp")
+        signed_at = datetime.now(UTC).isoformat(timespec="seconds")
         with tmp.open("w") as f:
             for record in records:
-                f.write(json.dumps(record, sort_keys=True) + "\n")
+                clean = clean_record_for_storage(record)
+                f.write(json.dumps(seal_record(clean, self.root, signed_at=signed_at), sort_keys=True) + "\n")
         tmp.replace(self.records_path)
 
     def solution_for_record(self, record: dict[str, Any]) -> dict[str, Any]:
@@ -215,6 +231,75 @@ class SolutionStore:
         setups = sorted(setups)
         return ["All", *setups]
 
+    def reference_record_for_case(self, case: str, metric_symbol: str | None = None) -> dict[str, Any] | None:
+        candidates = [
+            self.normalized_public_record(record)
+            for record in self.load_reference_records()
+            if not record.get("_integrity_errors") and str(record.get("case")) == case
+        ]
+        if metric_symbol:
+            symbol_candidates = [record for record in candidates if str(record.get("metric_symbol") or "s") == metric_symbol]
+            if symbol_candidates:
+                candidates = symbol_candidates
+        if not candidates:
+            return None
+        return min(candidates, key=metric_float)
+
+    def submission_metric_symbol(self, case: str) -> str:
+        reference = self.reference_record_for_case(case)
+        if reference is not None:
+            return str(reference.get("metric_symbol") or "s")
+        return "s"
+
+    @staticmethod
+    def metric_value_for_side(side: float, metric_symbol: str) -> float:
+        return side * 0.5 if metric_symbol == "r" else side
+
+    def previous_best_entry(self, record: dict[str, Any]) -> dict[str, Any]:
+        date_info = record.get("record_date")
+        if not isinstance(date_info, dict):
+            if record.get("record_type") == "reference":
+                date_info = date_from_friedman_record(record)
+            else:
+                date_info = date_from_submission(record)
+        source_url = str(record.get("source_url") or "")
+        meta = record.get("friedman_reference")
+        if isinstance(meta, dict):
+            source_url = str(meta.get("source_page") or source_url)
+        return {
+            "case": record.get("case"),
+            "record_type": record.get("record_type") or ("verified" if record.get("verified") else "reference"),
+            "author": record.get("submitted_by") or "unknown",
+            "date": date_info,
+            "metric_symbol": record.get("metric_symbol") or "s",
+            "metric_value": metric_float(record),
+            "metric_expression": record.get("metric_expression") or "",
+            "source": record.get("source") or ("Verified submission" if record.get("verified") else "Erich Friedman Packing Center"),
+            "source_url": source_url,
+            "reference_text": record.get("reference_text") or "",
+        }
+
+    def current_best_for_case(self, case: str, metric_symbol: str) -> dict[str, Any] | None:
+        candidates: list[dict[str, Any]] = []
+        candidates.extend(
+            self.normalized_public_record(record)
+            for record in self.load_reference_records()
+            if not record.get("_integrity_errors")
+            and str(record.get("case")) == case
+            and str(record.get("metric_symbol") or "s") == metric_symbol
+        )
+        candidates.extend(
+            self.normalized_public_record(record)
+            for record in self.load_records()
+            if record.get("verified")
+            and not record.get("_integrity_errors")
+            and str(record.get("case")) == case
+            and str(record.get("metric_symbol") or "s") == metric_symbol
+        )
+        if not candidates:
+            return None
+        return min(candidates, key=metric_float)
+
     def append_verified_submission(
         self,
         solution: dict[str, Any],
@@ -258,23 +343,34 @@ class SolutionStore:
             reference_side = comparison.get("friedman_displayed_side")
             if reference_side is None:
                 reference_side = comparison.get("reference_side")
-            reference_side = float(reference_side) if reference_side not in (None, "") else None
             side = float(result.side or 0.0)
+            metric_symbol = self.submission_metric_symbol(result.case)
+            metric_value = self.metric_value_for_side(side, metric_symbol)
+            previous = self.current_best_for_case(result.case, metric_symbol)
+            previous_bests = [self.previous_best_entry(previous)] if previous is not None else []
+            if reference_side is None and previous is not None:
+                reference_side = metric_float(previous)
+            reference_side = float(reference_side) if reference_side not in (None, "") else None
             record = {
                 "id": rid,
                 "case": result.case,
                 "setup": result.setup,
                 "n": result.n,
                 "side": side,
+                "metric_symbol": metric_symbol,
+                "metric_value": metric_value,
                 "density": result.density,
                 "submitted_by": submitter,
                 "submitted_at": now,
+                "database_inserted_at": now,
+                "record_date": date_from_submission({"submitted_at": now}),
                 "verified": True,
                 "max_boundary_excess": result.max_boundary_excess,
                 "max_pair_overlap_depth": result.max_pair_overlap_depth,
                 "tolerance": tolerance,
                 "reference_side": reference_side,
-                "improvement": (reference_side - side) if reference_side is not None else None,
+                "improvement": (reference_side - metric_value) if reference_side is not None else None,
+                "previous_bests": previous_bests,
                 "source_url": source_url.strip(),
                 "notes": notes.strip(),
                 "solution_path": str(solution_path.relative_to(self.root.parent)),