Fix Amaldi checker numerical overflow and document hardening

Validate finite hyperplane coefficients and use high-precision distances to reject finite overflow attacks while preserving scaling equivalence. All six published references and nine targeted regression checks passed. Update Hardened feasibility checkers in RELEASE_NOTES.md.

RELEASE_NOTES.md

@@ -37,6 +37,7 @@ The feasibility checkers were systematically audited and strengthened:
 - Checkers no longer trust fixed problem parameters supplied by a candidate solution.
 - The affected solver-dependent checkers were converted to validate complete witnesses without invoking an optimization solver at evaluation time.
 - Checker execution limits and error handling were made more robust for large solutions.
+- **Numerically stable hyperplane geometry (`amaldi2013`, 2026-10-10).** The checker now validates finite numeric coefficients and computes distances using high-precision decimal arithmetic, preventing finite but extreme normal vectors from overflowing the floating-point norm and incorrectly accepting infeasible coverage. Exactly zero normals are rejected, while valid large, small, and negative rescalings remain equivalent. All six published Gurobi reference solutions were revalidated, and targeted overflow and scaling regressions passed.
 
 All published Gurobi reference solutions were revalidated using the updated checkers.
 

tasks/amaldi2013/feasibility_check.py

@@ -20,6 +20,8 @@ This patched version additionally enforces:
 import argparse
 import json
 import math
+import sys
+from decimal import Decimal, localcontext
 import numpy as np
 
 # FRONTIEROR_RELEASE_CONTRACT_V2
@@ -163,6 +165,38 @@ def write_json(path, data):
         json.dump(data, f, indent=2)
 
 
+def _finite_decimal(value):
+    # JSON numbers only; do not let strings, booleans or nonfinite values
+    # participate in geometry. Decimal avoids float norm/dot overflow.
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError("hyperplane coefficients must be finite JSON numbers")
+    if isinstance(value, float) and not math.isfinite(value):
+        raise ValueError("hyperplane coefficients must be finite JSON numbers")
+    return Decimal(str(value))
+
+
+def _geometric_distances(points, w, w0, dimension):
+    if not isinstance(w, list) or len(w) != dimension:
+        raise ValueError("hyperplane normal dimension does not match instance")
+    with localcontext() as ctx:
+        # Covers the exponent span of products of finite binary64 values,
+        # including subnormals and cancellation, without changing tolerance.
+        ctx.prec = 1600
+        normal = [_finite_decimal(v) for v in w]
+        offset = _finite_decimal(w0)
+        norm = sum((v * v for v in normal), Decimal(0)).sqrt()
+        if norm == 0:
+            return None
+        cap = Decimal(str(sys.float_info.max))
+        distances = []
+        for point in points:
+            residual = sum((_finite_decimal(v) * a for v, a in zip(point, normal)), Decimal(0)) - offset
+            distance = abs(residual) / norm
+            # Finite diagnostic values even for geometrically enormous distances.
+            distances.append(float(min(distance, cap)))
+        return distances
+
+
 def check_feasibility(instance, solution):
     tol = 1e-5
     eps = 1e-5
@@ -216,31 +250,22 @@ def check_feasibility(instance, solution):
     # ----------------------------------------------------------------
     constraint_1_violated = False
     for j, hp in enumerate(hyperplanes):
-        w = np.array(hp["w"])
-        w0 = hp["w0"]
-        w_norm = float(np.linalg.norm(w))
-        if w_norm < tol:
-            # Degenerate hyperplane (zero normal) — any assignment is invalid
+        try:
+            distances = _geometric_distances(instance["points"], hp["w"], hp["w0"], d)
+        except (ValueError, ArithmeticError) as exc:
+            return {"feasible": False, "violated_constraints": [5],
+                    "violations": [f"Invalid hyperplane {j}: {exc}"],
+                    "violation_magnitudes": []}
+        if distances is None:
+            # Exactly zero is degenerate; tiny nonzero rescalings are valid.
             if int(D[:, j].sum()) > 0:
-                if not constraint_1_violated:
-                    constraint_1_violated = True
-                    violated_constraints_set.add(1)
-                violation_magnitudes.append({
-                    "constraint": 1,
-                    "lhs": float(w_norm),
-                    "rhs": float(tol),
-                    "raw_excess": float(tol - w_norm),
-                    "normalizer": max(tol, eps),
-                    "ratio": float((tol - w_norm) / max(tol, eps))
-                })
-                violations.append(
-                    f"Constraint 1 violated: hyperplane {j} has zero normal vector "
-                    f"but has assigned points"
-                )
+                constraint_1_violated = True
+                violated_constraints_set.add(1)
+                violations.append(f"Constraint 1 violated: hyperplane {j} has zero normal vector but has assigned points")
             continue
         for i in range(n):
             if D[i, j] == 1:
-                dist = abs(np.dot(points[i], w) - w0) / w_norm
+                dist = distances[i]
                 if dist > epsilon + tol:
                     violation_amount = dist - epsilon
                     normalizer = max(abs(epsilon), eps)
@@ -254,7 +279,7 @@ def check_feasibility(instance, solution):
                         "rhs": float(epsilon),
                         "raw_excess": float(violation_amount),
                         "normalizer": float(normalizer),
-                        "ratio": float(ratio)
+                        "ratio": float(min(ratio, sys.float_info.max))
                     })
 
     if constraint_1_violated:
@@ -291,7 +316,7 @@ def check_feasibility(instance, solution):
                     "rhs": float(true_obj),
                     "raw_excess": float(abs_diff),
                     "normalizer": float(normalizer),
-                    "ratio": float(ratio)
+                    "ratio": float(min(ratio, sys.float_info.max))
                 })
                 violations.append(
                     f"Constraint 2 (Eq.2, objective consistency) violated: "
@@ -321,7 +346,7 @@ def check_feasibility(instance, solution):
                 "rhs": float(rhs_val),
                 "raw_excess": float(violation_amount),
                 "normalizer": float(normalizer),
-                "ratio": float(ratio)
+                "ratio": float(min(ratio, sys.float_info.max))
             })
 
     if constraint_3_violated:
@@ -355,7 +380,7 @@ def check_feasibility(instance, solution):
                     "rhs": float(rhs_val),
                     "raw_excess": float(violation_amount),
                     "normalizer": float(normalizer),
-                    "ratio": float(ratio)
+                    "ratio": float(min(ratio, sys.float_info.max))
                 })
 
     if constraint_4_violated:
@@ -386,7 +411,7 @@ def check_feasibility(instance, solution):
                 "rhs": float(rhs_val),
                 "raw_excess": float(violation_amount),
                 "normalizer": float(normalizer),
-                "ratio": float(ratio)
+                "ratio": float(min(ratio, sys.float_info.max))
             })
 
     if constraint_5_violated:
@@ -417,7 +442,7 @@ def check_feasibility(instance, solution):
                         "rhs": float(round(val)),
                         "raw_excess": float(violation_amount),
                         "normalizer": float(normalizer),
-                        "ratio": float(ratio)
+                        "ratio": float(min(ratio, sys.float_info.max))
                     })
 
     if constraint_6_violated:
@@ -466,7 +491,7 @@ def check_feasibility(instance, solution):
                     "rhs": float(round(val)),
                     "raw_excess": float(violation_amount),
                     "normalizer": float(normalizer),
-                    "ratio": float(ratio)
+                    "ratio": float(min(ratio, sys.float_info.max))
                 })
 
     if constraint_7_violated: