| """Compare claimed container sides against stored bounds. Deterministic, no LLM. |
| Metric per n: smaller container side s is better (see sources.md; relative score s/sqrt(n)-1 is monotone in s for fixed n).""" |
| from __future__ import annotations |
| from dataclasses import dataclass, asdict, field |
| import json |
| import math |
|
|
|
|
| @dataclass |
| class Bound: |
| n: int |
| s: float |
| source: str |
| date: str |
| verified: bool |
| basis: str = "" |
| exact: str = "" |
|
|
|
|
| def load_bounds(path): |
| with open(path) as f: |
| return {int(d["n"]): Bound(**d) for d in json.load(f)} |
|
|
|
|
| def save_bounds(bounds, path): |
| with open(path, "w") as f: |
| json.dump([asdict(b) for _, b in sorted(bounds.items())], f, indent=2) |
|
|
|
|
| def area_lower_bound(n): |
| return math.sqrt(n) |
|
|
|
|
| def trivial_upper_bound(n): |
| return math.ceil(math.sqrt(n)) |
|
|
|
|
| def rel_score(n, s): |
| return s / math.sqrt(n) - 1.0 |
|
|
|
|
| |
| |
| VALIDATION_EPS = 1e-9 |
| IMPROVEMENT_MATERIAL = 1e-8 |
| assert IMPROVEMENT_MATERIAL > VALIDATION_EPS |
|
|
|
|
| def float_near_bound_margin(n): |
| """Float validation allows each pair to overlap by up to VALIDATION_EPS. Along a row of ~sqrt(n)..n |
| squares those slacks add up, so the true required side can be up to ~n*VALIDATION_EPS smaller than |
| the float check suggests. A float-validated (non-proof) claim is promoted to an improvement only if it |
| beats the bound by more than this; otherwise it stays a candidate until an exact/interval check.""" |
| return IMPROVEMENT_MATERIAL + n * VALIDATION_EPS |
|
|
|
|
| def classify(claim_s, bound_s, validation=None, material=IMPROVEMENT_MATERIAL): |
| """Return (status, delta), delta = claim - bound (negative is better). |
| partial: no side. impossible: s < sqrt(n) is ruled out by area (checked by caller). |
| invalid: coordinates failed validation. improvement: validated and better. |
| unverified: better than bound but no coordinates checked (a CANDIDATE, never an improvement). |
| unchanged: within +-material. worse. no_baseline: bound unknown.""" |
| if claim_s is None: |
| return "partial", None |
| if bound_s is None: |
| if validation is not None and not validation["valid"]: |
| return "invalid", None |
| return "no_baseline", None |
| delta = claim_s - bound_s |
| if validation is not None and not validation["valid"]: |
| return "invalid", delta |
| if delta < -material: |
| return ("improvement", delta) if validation is not None else ("unverified", delta) |
| if delta > material: |
| return "worse", delta |
| return "unchanged", delta |
|
|
|
|
| def find_conflicts(claims, tol=1e-6): |
| """claims: dicts with n, s, source_url. One entry per n whose sides differ by > tol |
| across distinct sources. s=None ignored.""" |
| by_n = {} |
| for c in claims: |
| if c.get("s") is not None: |
| by_n.setdefault(c["n"], []).append(c) |
| out = [] |
| for n, cs in sorted(by_n.items()): |
| vals = [c["s"] for c in cs] |
| if max(vals) - min(vals) > tol and len({c.get("source_url") for c in cs}) > 1: |
| out.append({"n": n, "spread": max(vals) - min(vals), |
| "claims": [{"s": c["s"], "source_url": c.get("source_url")} for c in cs]}) |
| return out |
|
|
