Harden verifier and record metric validation

app.py

@@ -2815,14 +2815,18 @@ def current_top_for_case(case: str) -> dict[str, Any] | None:
 
 
 def submitted_metric_for_result(result: dict[str, Any], current: dict[str, Any] | None) -> tuple[str, float | None]:
+    symbol = str(result.get("metric_symbol") or (current or {}).get("metric_symbol") or "s")
     try:
-        side = float(result.get("side"))
+        metric = float(result.get("metric_value"))
     except (TypeError, ValueError):
-        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
+        try:
+            side = float(result.get("side"))
+        except (TypeError, ValueError):
+            return symbol, None
+        metric = side * 0.5 if symbol == "r" else side
+    if not math.isfinite(metric):
+        return symbol, None
+    return symbol, metric
 
 
 def submission_gate(result: dict[str, Any]) -> tuple[bool, str]:
@@ -2834,6 +2838,9 @@ def submission_gate(result: dict[str, Any]) -> tuple[bool, str]:
         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."
+    current_symbol = str(current.get("metric_symbol") or symbol)
+    if current_symbol != symbol:
+        return False, f"Submitted metric symbol {symbol!r} does not match current record metric symbol {current_symbol!r}."
 
     current_metric = record_metric_float(current)
     if current_metric is None:
@@ -2854,11 +2861,18 @@ def submission_gate(result: dict[str, Any]) -> tuple[bool, str]:
 
 def result_markdown(result: dict[str, Any], gate: tuple[bool, str] | None = None) -> str:
     if result["ok"]:
+        metric_symbol_text = result.get("metric_symbol") or "s"
+        metric_value_text = result.get("metric_value")
+        try:
+            metric_line = f"- Container metric: `{metric_symbol_text} = {float(metric_value_text):.10f}`\n"
+        except (TypeError, ValueError):
+            metric_line = ""
         text = (
             "### Verification Passed\n\n"
             f"- Case: `{result['case']}`\n"
             f"- Items: `{result['n']}`\n"
-            f"- Container side/metric: `{result['side']:.10f}`\n"
+            f"{metric_line}"
+            f"- Container side/diameter: `{result['side']:.10f}`\n"
             f"- Density: `{result['density']:.6f}`\n"
             f"- Max boundary excess: `{result['max_boundary_excess']:.3e}`\n"
             f"- Max pair overlap depth: `{result['max_pair_overlap_depth']:.3e}`\n"

packing_benchmark/store.py

@@ -344,8 +344,8 @@ class SolutionStore:
             if reference_side is None:
                 reference_side = comparison.get("reference_side")
             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)
+            metric_symbol = result.metric_symbol or self.submission_metric_symbol(result.case)
+            metric_value = float(result.metric_value) if result.metric_value is not None else 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:

packing_benchmark/verifier.py

@@ -4,12 +4,14 @@ import copy
 import hashlib
 import json
 import math
+import re
 from dataclasses import dataclass, field
 from typing import Any
 
 
 PI = math.pi
 DEFAULT_TOLERANCE = 1.0e-8
+CASE_PATTERN = re.compile(r"^[a-z0-9]+in[a-z0-9]+@[1-9][0-9]*$")
 
 
 @dataclass
@@ -19,6 +21,8 @@ class VerificationResult:
     setup: str
     n: int
     side: float | None
+    metric_symbol: str | None
+    metric_value: float | None
     density: float | None
     max_boundary_excess: float
     max_pair_overlap_depth: float
@@ -33,6 +37,8 @@ class VerificationResult:
             "setup": self.setup,
             "n": self.n,
             "side": self.side,
+            "metric_symbol": self.metric_symbol,
+            "metric_value": self.metric_value,
             "density": self.density,
             "max_boundary_excess": self.max_boundary_excess,
             "max_pair_overlap_depth": self.max_pair_overlap_depth,
@@ -88,67 +94,107 @@ def regular_area(sides: int, radius: float) -> float:
     return 0.5 * sides * radius * radius * math.sin(2.0 * PI / sides)
 
 
+def finite_float(value: Any, label: str) -> float:
+    try:
+        out = float(value)
+    except (TypeError, ValueError):
+        raise ValueError(f"{label} must be numeric") from None
+    if not math.isfinite(out):
+        raise ValueError(f"{label} must be finite")
+    return out
+
+
+def integer_value(value: Any, label: str) -> int:
+    if isinstance(value, bool):
+        raise ValueError(f"{label} must be an integer")
+    if isinstance(value, int):
+        out = value
+    elif isinstance(value, float):
+        if not math.isfinite(value) or not value.is_integer():
+            raise ValueError(f"{label} must be an integer")
+        out = int(value)
+    elif isinstance(value, str):
+        if not re.fullmatch(r"[+-]?\d+", value.strip()):
+            raise ValueError(f"{label} must be an integer")
+        out = int(value)
+    else:
+        raise ValueError(f"{label} must be an integer")
+    return out
+
+
 def shape_type(spec: dict[str, Any]) -> str:
     return str(spec.get("type", "")).strip().lower()
 
 
-def regular_radius(spec: dict[str, Any]) -> float:
-    sides = int(spec["sides"])
+def regular_sides(spec: dict[str, Any]) -> int:
+    if "sides" not in spec:
+        raise ValueError("regular_polygon requires sides")
+    sides = integer_value(spec["sides"], "regular_polygon sides")
     if sides < 3:
         raise ValueError("regular polygons need at least 3 sides")
+    return sides
+
+
+def regular_radius(spec: dict[str, Any]) -> float:
+    sides = regular_sides(spec)
     if "circumradius" in spec:
-        radius = float(spec["circumradius"])
+        radius = finite_float(spec["circumradius"], "regular_polygon circumradius")
     elif "side_length" in spec:
-        radius = float(spec["side_length"]) / (2.0 * math.sin(PI / sides))
+        side = finite_float(spec["side_length"], "regular_polygon side_length")
+        radius = side / (2.0 * math.sin(PI / sides))
     else:
         raise ValueError("regular_polygon requires side_length or circumradius")
-    if radius <= 0.0 or not math.isfinite(radius):
+    if radius <= 0.0:
         raise ValueError("regular_polygon radius must be positive")
     return radius
 
 
 def regular_side_length(spec: dict[str, Any]) -> float:
-    sides = int(spec["sides"])
+    sides = regular_sides(spec)
     if "side_length" in spec:
-        side = float(spec["side_length"])
+        side = finite_float(spec["side_length"], "regular_polygon side_length")
     else:
         side = 2.0 * regular_radius(spec) * math.sin(PI / sides)
-    if side <= 0.0 or not math.isfinite(side):
+    if side <= 0.0:
         raise ValueError("regular_polygon side_length must be positive")
     return side
 
 
 def circle_radius(spec: dict[str, Any]) -> float:
     if "radius" in spec:
-        radius = float(spec["radius"])
+        radius = finite_float(spec["radius"], "circle radius")
     elif "diameter" in spec:
-        radius = 0.5 * float(spec["diameter"])
+        radius = 0.5 * finite_float(spec["diameter"], "circle diameter")
     else:
         raise ValueError("circle requires radius or diameter")
-    if radius <= 0.0 or not math.isfinite(radius):
+    if radius <= 0.0:
         raise ValueError("circle radius must be positive")
     return radius
 
 
 def rectangle_dims(spec: dict[str, Any]) -> tuple[float, float]:
-    width = float(spec["width"])
-    height = float(spec["height"])
-    if width <= 0.0 or height <= 0.0 or not math.isfinite(width + height):
+    width = finite_float(spec["width"], "rectangle width")
+    height = finite_float(spec["height"], "rectangle height")
+    if width <= 0.0 or height <= 0.0:
         raise ValueError("rectangle width and height must be positive")
     return width, height
 
 
+def optional_rotation(spec: dict[str, Any], field: str = "orientation_radians") -> float:
+    return finite_float(spec.get(field, 0.0), field)
+
+
 def make_item_shape(item: dict[str, Any], placement: dict[str, Any]) -> dict[str, Any]:
     kind = shape_type(item)
-    x = float(placement.get("x", 0.0))
-    y = float(placement.get("y", 0.0))
-    rotation = float(placement.get("rotation_radians", 0.0))
-    if not math.isfinite(x + y + rotation):
-        raise ValueError("placement coordinates and rotation must be finite")
+    if not isinstance(placement, dict):
+        raise ValueError("each placement must be an object")
+    x = finite_float(placement.get("x", 0.0), "placement x")
+    y = finite_float(placement.get("y", 0.0), "placement y")
+    rotation = finite_float(placement.get("rotation_radians", 0.0), "placement rotation_radians")
 
     if kind == "regular_polygon":
         radius = regular_radius(item)
-        sides = int(item["sides"])
+        sides = regular_sides(item)
         return {
             "kind": "polygon",
             "vertices": regular_vertices(sides, radius, rotation=rotation, center=(x, y)),
@@ -174,10 +220,10 @@ def make_item_shape(item: dict[str, Any], placement: dict[str, Any]) -> dict[str
 
 def make_container_shape(container: dict[str, Any]) -> dict[str, Any]:
     kind = shape_type(container)
-    rotation = float(container.get("orientation_radians", 0.0))
+    rotation = optional_rotation(container)
     if kind == "regular_polygon":
         radius = regular_radius(container)
-        sides = int(container["sides"])
+        sides = regular_sides(container)
         return {
             "kind": "polygon",
             "vertices": regular_vertices(sides, radius, rotation=rotation),
@@ -190,6 +236,8 @@ def make_container_shape(container: dict[str, Any]) -> dict[str, Any]:
             "kind": "polygon",
             "vertices": rectangle_vertices(width, height, rotation=rotation),
             "side": max(width, height),
+            "width": width,
+            "height": height,
             "area": width * height,
         }
     if kind == "circle":
@@ -217,16 +265,26 @@ def solution_setup(solution: dict[str, Any]) -> str:
 def shape_label(spec: dict[str, Any]) -> str:
     kind = shape_type(spec)
     if kind == "regular_polygon":
-        sides = int(spec.get("sides", 0))
+        sides = regular_sides(spec)
         names = {3: "tri", 4: "squ", 5: "pen", 6: "hex", 7: "hep", 8: "oct"}
         return names.get(sides, f"{sides}gon")
     if kind == "circle":
         return "cir"
     if kind == "rectangle":
+        width, height = rectangle_dims(spec)
+        ratio = max(width, height) / min(width, height)
+        if abs(ratio - 1.0) <= 1.0e-9:
+            return "squ"
+        if abs(ratio - 2.0) <= 1.0e-9:
+            return "dom"
         return "rect"
     return kind or "shape"
 
 
+def inferred_setup(item: dict[str, Any], container: dict[str, Any]) -> str:
+    return f"{shape_label(item)}in{shape_label(container)}"
+
+
 def solution_case(solution: dict[str, Any]) -> str:
     placements = solution.get("placements", [])
     n = len(placements) if isinstance(placements, list) else 0
@@ -242,6 +300,51 @@ def parsed_case_count(case: str) -> int | None:
         return None
 
 
+def parsed_case_setup(case: str) -> str | None:
+    if "@" not in case:
+        return None
+    setup, count_text = case.rsplit("@", 1)
+    if not setup or not count_text:
+        return None
+    try:
+        count = int(count_text)
+    except ValueError:
+        return None
+    if count <= 0:
+        return None
+    return setup
+
+
+def container_metric(container_shape: dict[str, Any]) -> tuple[str, float]:
+    if container_shape["kind"] == "circle":
+        return "r", float(container_shape["radius"])
+    width = container_shape.get("width")
+    height = container_shape.get("height")
+    if width is not None and height is not None:
+        short = min(float(width), float(height))
+        long = max(float(width), float(height))
+        if abs(long / short - 2.0) <= 1.0e-9:
+            return "s", short
+    return "s", float(container_shape["side"])
+
+
+def finite_points(points: list[tuple[float, float]], label: str) -> None:
+    for x, y in points:
+        if not math.isfinite(x + y):
+            raise ValueError(f"{label} contains non-finite coordinates")
+
+
+def validate_shape_finite(shape: dict[str, Any], label: str) -> None:
+    if shape["kind"] == "circle":
+        cx, cy = shape["center"]
+        if not math.isfinite(cx + cy + shape["radius"] + shape["area"]):
+            raise ValueError(f"{label} contains non-finite circle geometry")
+        return
+    finite_points(shape["vertices"], label)
+    if not math.isfinite(shape["area"]):
+        raise ValueError(f"{label} contains non-finite polygon area")
+
+
 def polygon_axes(poly: list[tuple[float, float]]) -> list[tuple[float, float]]:
     axes: list[tuple[float, float]] = []
     for i, (x1, y1) in enumerate(poly):
@@ -368,13 +471,19 @@ def normalize_solution(solution: dict[str, Any]) -> dict[str, Any]:
 def verify_solution(solution: dict[str, Any], tolerance: float = DEFAULT_TOLERANCE) -> VerificationResult:
     errors: list[str] = []
     warnings: list[str] = []
-    case = solution_case(solution)
-    setup = solution_setup(solution)
+    case = str(solution.get("case") or "")
+    setup = str(solution.get("setup") or "")
     side: float | None = None
+    metric_symbol: str | None = None
+    metric_value: float | None = None
     density: float | None = None
     n = 0
 
     try:
+        tolerance = finite_float(tolerance, "tolerance")
+        if tolerance < 0.0:
+            raise ValueError("tolerance must be non-negative")
+
         placements = solution.get("placements")
         if not isinstance(placements, list):
             raise ValueError("placements must be a list")
@@ -390,11 +499,31 @@ def verify_solution(solution: dict[str, Any], tolerance: float = DEFAULT_TOLERAN
         if not isinstance(item, dict) or not isinstance(container_spec, dict):
             raise ValueError("item and container must be objects")
 
+        actual_setup = inferred_setup(item, container_spec)
+        if not setup:
+            setup = parsed_case_setup(case) or actual_setup
+        if not case:
+            case = f"{actual_setup}@{n}"
+        if not CASE_PATTERN.fullmatch(case):
+            errors.append("case must have form '<item>in<container>@<positive integer>'")
+        case_setup = parsed_case_setup(case)
+        if case_setup is not None and case_setup != actual_setup:
+            errors.append(f"case setup {case_setup!r} does not match item/container geometry {actual_setup!r}")
+        if setup != actual_setup:
+            errors.append(f"setup {setup!r} does not match item/container geometry {actual_setup!r}")
+        setup = actual_setup
+
         container = make_container_shape(container_spec)
+        validate_shape_finite(container, "container")
         side = container["side"]
+        metric_symbol, metric_value = container_metric(container)
         shapes = [make_item_shape(item, placement) for placement in placements]
+        for index, shape in enumerate(shapes, start=1):
+            validate_shape_finite(shape, f"placement {index}")
         item_area = sum(shape["area"] for shape in shapes)
         density = item_area / container["area"] if container["area"] > 0.0 else None
+        if density is None or not math.isfinite(density):
+            errors.append("density is not finite")
 
         max_boundary = max(boundary_excess(shape, container) for shape in shapes)
         max_overlap = -float("inf")
@@ -415,6 +544,8 @@ def verify_solution(solution: dict[str, Any], tolerance: float = DEFAULT_TOLERAN
             setup=setup,
             n=n,
             side=side,
+            metric_symbol=metric_symbol,
+            metric_value=metric_value,
             density=density,
             max_boundary_excess=max_boundary,
             max_pair_overlap_depth=max_overlap,
@@ -430,6 +561,8 @@ def verify_solution(solution: dict[str, Any], tolerance: float = DEFAULT_TOLERAN
             setup=setup,
             n=n,
             side=side,
+            metric_symbol=metric_symbol,
+            metric_value=metric_value,
             density=density,
             max_boundary_excess=float("nan"),
             max_pair_overlap_depth=float("nan"),
@@ -439,8 +572,55 @@ def verify_solution(solution: dict[str, Any], tolerance: float = DEFAULT_TOLERAN
         )
 
 
+def close_enough(a: Any, b: Any, tolerance: float) -> bool:
+    try:
+        left = float(a)
+        right = float(b)
+    except (TypeError, ValueError):
+        return False
+    if not math.isfinite(left + right):
+        return False
+    return abs(left - right) <= max(tolerance, abs(right) * tolerance)
+
+
+def verify_record_solution(
+    record: dict[str, Any],
+    solution: dict[str, Any],
+    tolerance: float = DEFAULT_TOLERANCE,
+) -> list[str]:
+    """Verify that a stored leaderboard row agrees with its coordinate JSON."""
+
+    result = verify_solution(solution, tolerance=tolerance)
+    errors = list(result.errors)
+    if str(record.get("case") or "") != result.case:
+        errors.append(f"record case {record.get('case')!r} does not match verified case {result.case!r}")
+    if str(record.get("setup") or "") != result.setup:
+        errors.append(f"record setup {record.get('setup')!r} does not match verified setup {result.setup!r}")
+    try:
+        record_n = int(record.get("n"))
+    except (TypeError, ValueError):
+        record_n = -1
+    if record_n != result.n:
+        errors.append(f"record n {record.get('n')!r} does not match verified n {result.n}")
+
+    if record.get("side") is not None and not close_enough(record.get("side"), result.side, tolerance):
+        errors.append(f"record side {record.get('side')!r} does not match verified side {result.side!r}")
+
+    record_symbol = record.get("metric_symbol")
+    if record_symbol is not None and str(record_symbol) != str(result.metric_symbol):
+        errors.append(f"record metric_symbol {record_symbol!r} does not match verified metric_symbol {result.metric_symbol!r}")
+
+    record_metric = record.get("metric_value")
+    if record_metric is not None and not close_enough(record_metric, result.metric_value, tolerance):
+        errors.append(f"record metric_value {record_metric!r} does not match verified metric_value {result.metric_value!r}")
+    return errors
+
+
 def load_solution_json(text: str) -> dict[str, Any]:
-    payload = json.loads(text)
+    def reject_constant(value: str) -> None:
+        raise ValueError(f"invalid JSON numeric constant {value}")
+
+    payload = json.loads(text, parse_constant=reject_constant)
     if not isinstance(payload, dict):
         raise ValueError("submission JSON must be an object")
     return payload

tests/test_verifier.py

@@ -10,7 +10,7 @@ sys.path.insert(0, str(ROOT))
 
 from packing_benchmark.renderer import svg_markup  # noqa: E402
 from packing_benchmark.store import SolutionStore  # noqa: E402
-from packing_benchmark.verifier import verify_solution  # noqa: E402
+from packing_benchmark.verifier import load_solution_json, verify_record_solution, verify_solution  # noqa: E402
 
 
 def test_seed_records_verify() -> None:
@@ -34,6 +34,97 @@ def test_rejects_overlapping_pair() -> None:
     assert result.max_pair_overlap_depth > 0
 
 
+def test_rejects_boundary_protrusion() -> None:
+    solution = {
+        "case": "squinsqu@1",
+        "item": {"type": "regular_polygon", "sides": 4, "side_length": 1},
+        "container": {"type": "regular_polygon", "sides": 4, "side_length": 1},
+        "placements": [
+            {"x": 0.6, "y": 0.0, "rotation_radians": 0},
+        ],
+    }
+    result = verify_solution(solution)
+    assert not result.ok
+    assert result.max_boundary_excess > 0
+
+
+def test_rejects_wrong_case_family() -> None:
+    solution = {
+        "case": "triintri@1",
+        "item": {"type": "circle", "radius": 0.5},
+        "container": {"type": "regular_polygon", "sides": 4, "side_length": 2},
+        "placements": [
+            {"x": 0.0, "y": 0.0, "rotation_radians": 0},
+        ],
+    }
+    result = verify_solution(solution)
+    assert not result.ok
+    assert any("does not match item/container geometry" in error for error in result.errors)
+
+
+def test_rejects_wrong_setup_field() -> None:
+    solution = {
+        "case": "cirinsqu@1",
+        "setup": "triintri",
+        "item": {"type": "circle", "radius": 0.5},
+        "container": {"type": "rectangle", "width": 2.0, "height": 2.0},
+        "placements": [
+            {"x": 0.0, "y": 0.0, "rotation_radians": 0},
+        ],
+    }
+    result = verify_solution(solution)
+    assert not result.ok
+    assert any("setup" in error and "does not match" in error for error in result.errors)
+
+
+def test_circle_container_metric_is_radius() -> None:
+    solution = {
+        "case": "triincir@1",
+        "item": {"type": "regular_polygon", "sides": 3, "side_length": 1},
+        "container": {"type": "circle", "radius": 1.0},
+        "placements": [
+            {"x": 0.0, "y": 0.0, "rotation_radians": 0},
+        ],
+    }
+    result = verify_solution(solution)
+    assert result.ok
+    assert result.side == 2.0
+    assert result.metric_symbol == "r"
+    assert result.metric_value == 1.0
+
+
+def test_rejects_non_finite_json_numbers() -> None:
+    try:
+        load_solution_json('{"case": "cirincir@1", "item": {"type": "circle", "radius": NaN}}')
+    except ValueError as exc:
+        assert "invalid JSON numeric constant" in str(exc)
+    else:
+        raise AssertionError("NaN JSON was accepted")
+
+
+def test_record_solution_mismatch_is_detected() -> None:
+    solution = {
+        "case": "cirinsqu@1",
+        "item": {"type": "circle", "radius": 0.5},
+        "container": {"type": "rectangle", "width": 2.0, "height": 2.0},
+        "placements": [
+            {"x": 0.0, "y": 0.0, "rotation_radians": 0},
+        ],
+    }
+    errors = verify_record_solution(
+        {
+            "case": "cirinsqu@1",
+            "setup": "cirinsqu",
+            "n": 1,
+            "side": 3.0,
+            "metric_symbol": "s",
+            "metric_value": 3.0,
+        },
+        solution,
+    )
+    assert any("record side" in error for error in errors)
+
+
 def test_store_and_svg_paths_exist() -> None:
     store = SolutionStore(ROOT / "data")
     records = store.best_records("All")