Require complete guillotine cutting witnesses for feasibility validation

RELEASE_NOTES.md

@@ -36,6 +36,7 @@ The feasibility checkers were systematically audited and strengthened:
 - Capacity, flow, balance, linking, integrality, and task-specific constraints are checked where applicable. Geometric checks use numerically stable calculations to avoid overflow-based false acceptance.
 - 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.
+- Cutting-stock validation now requires complete guillotine-cut witnesses and checks geometry, material flow, item counts, and objective consistency.
 - Checker execution limits and error handling were made more robust for large solutions.
 
 All published Gurobi reference solutions were revalidated using the updated checkers.

tasks/furini2016/feasibility_check.py

@@ -16,12 +16,11 @@ Constraint numbering (top-to-bottom in the formulation section of math_model.txt
                          must equal the recomputed total profit
                          sum_{j in J_bar} p_j * y_j (eq 1).
 
-Since the solution only provides y values (items_selected), constraints involving
-x variables (1, 2, 3, 5) are checked via necessary conditions derivable from the
-flow-network structure:
-  - Total item area <= panel area (from constraints 1+2+3 combined)
-  - Each item fits within panel dimensions
-  - Constraint 5 (x integrality): not directly checkable from y-only solution
+A complete cutting-flow witness is required. Plate 0 is the trusted input
+panel, all cut positions and child dimensions are checked geometrically,
+all counts are finite nonnegative integers, and every selected item must
+consume a produced plate. Candidate in_J_bar flags are never trusted.
+Total selected area is additionally checked using trusted item dimensions.
 
 Constraint 7 is an objective-recomputation defense: the objective (eq 1) is a
 deterministic function of the y variables alone, and the solution carries every
@@ -34,7 +33,7 @@ import json
 import argparse
 
 # FRONTIEROR_RELEASE_CONTRACT_V2
-_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('items_selected', 'objective_value')
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('cuts_used', 'items_selected', 'objective_value', 'plates')
 _FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ()
 _FRONTIEROR_DERIVED_FIELD_RULES = ()
 _FRONTIEROR_CONDITIONAL_FIELD_RULES = ()
@@ -202,236 +201,143 @@ def record_violation(violations_list, magnitudes_list, constraint_idx, lhs, rhs,
 
 
 def check_feasibility(instance, solution):
+    """Validate a finite integer cutting-flow witness rooted in one trusted panel.
+
+    Cut geometry strictly decreases plate area. Together with integer flow
+    conservation this forms a DAG that can be expanded into a guillotine
+    cutting tree; unproduced plates cannot supply selected items.
     """
-    Check all hard constraints of the PP-G2KP model.
-    Returns (feasible, violated_constraints, violations, violation_magnitudes).
-    """
-    violated_constraints = set()
+    import math
+    from collections import defaultdict
+
     violations = []
     magnitudes = []
+    constraints = set()
+
+    def reject(message, constraint=8):
+        constraints.add(constraint)
+        violations.append(message)
+        magnitudes.append({"constraint": constraint, "lhs": 1.0, "rhs": 0.0,
+                           "raw_excess": 1.0, "normalizer": 1.0, "ratio": 1.0})
+
+    def integer(value, label, minimum=0):
+        # JSON integers are the public contract; integral finite floats also
+        # support conventional solver serialization without rounding fractions.
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise ValueError(f"{label} must be an integer")
+        if isinstance(value, float) and (not math.isfinite(value) or not value.is_integer()):
+            raise ValueError(f"{label} must be a finite integer")
+        value = int(value)
+        if value < minimum:
+            raise ValueError(f"{label} must be >= {minimum}")
+        return value
 
-    L = instance['panel']['length']
-    W = instance['panel']['width']
-    items = instance['items']
-    panel_area = L * W
-
-    # Build item lookup by id
-    item_by_id = {it['id']: it for it in items}
-
-    # Parse solution
-    items_selected = solution.get('items_selected', [])
-
-    # Aggregate y values per item_id
-    y_per_item = {}
-    for entry in items_selected:
-        iid = entry['item_id']
-        copies = entry['copies']
-        if iid in y_per_item:
-            y_per_item[iid] += copies
-        else:
-            y_per_item[iid] = copies
-
-    # ===================================================================
-    # Constraint 6 (eq 7): y_j >= 0, integer for all j in J_bar
-    # ===================================================================
-    for entry in items_selected:
-        iid = entry['item_id']
-        copies = entry['copies']
-
-        # Check non-negativity
-        if copies < -TOL:
-            lhs = copies
-            rhs = 0.0
-            violated_constraints.add(6)
-            record_violation(violations, magnitudes, 6, lhs, rhs,
-                             f"Constraint 6: y for item {iid} is negative ({copies})")
-
-        # Check integrality
-        if abs(copies - round(copies)) > TOL:
-            lhs = abs(copies - round(copies))
-            rhs = 0.0
-            violated_constraints.add(6)
-            record_violation(violations, magnitudes, 6, lhs, rhs,
-                             f"Constraint 6: y for item {iid} is not integer ({copies})")
-
-        # Check item exists in instance
-        if iid not in item_by_id:
-            violated_constraints.add(6)
-            violations.append(
-                f"Constraint 6: item {iid} in solution not found in instance")
-            magnitudes.append({
-                "constraint": 6,
-                "lhs": float(iid),
-                "rhs": 0.0,
-                "raw_excess": 1.0,
-                "normalizer": 1.0,
-                "ratio": 1.0,
-            })
-            continue
-
-        # Check plate_dims match item dimensions
-        item = item_by_id[iid]
-        pdims = entry.get('plate_dims', [])
-        if len(pdims) == 2:
-            if not (pdims[0] == item['length'] and pdims[1] == item['width']):
-                violated_constraints.add(6)
-                violations.append(
-                    f"Constraint 6: plate_dims {pdims} for item {iid} "
-                    f"do not match item dimensions [{item['length']}, {item['width']}]")
-                magnitudes.append({
-                    "constraint": 6,
-                    "lhs": 0.0,
-                    "rhs": 0.0,
-                    "raw_excess": 1.0,
-                    "normalizer": 1.0,
-                    "ratio": 1.0,
-                })
-
-    # ===================================================================
-    # Constraint 4 (eq 5): y_j <= u_j for all j in J_bar
-    # ===================================================================
-    for iid, total_copies in y_per_item.items():
-        if iid not in item_by_id:
-            continue  # already flagged above
-        item = item_by_id[iid]
-        u_j = item['copies']
-        lhs = total_copies
-        rhs = u_j
-        violation_amount = compute_violation(lhs, rhs, '<=')
-        if violation_amount > TOL:
-            violated_constraints.add(4)
-            record_violation(violations, magnitudes, 4, lhs, rhs,
-                             f"Constraint 4: item {iid} uses {total_copies} copies "
-                             f"but only {u_j} available")
-
-    # ===================================================================
-    # Constraints 1-3 (eqs 2-4): flow balance + panel use, using x (cuts)
-    #
-    # Solution provides cuts_used (x variables) and a plates list with
-    # in_J_bar flags, so we check the actual hard constraints rather than
-    # derived necessary conditions.
-    # ===================================================================
-    cuts_used = solution.get('cuts_used', [])
-    plates_info = solution.get('plates', [])
-    in_J_bar = {p['id']: bool(p.get('in_J_bar', False)) for p in plates_info}
-    plate_ids = {p['id'] for p in plates_info}
-
-    y_per_plate = {}
-    for entry in items_selected:
-        pid = entry.get('plate_id')
-        if pid is None:
-            continue
-        y_per_plate[pid] = y_per_plate.get(pid, 0) + entry['copies']
-
-    flow_in = {pid: 0 for pid in plate_ids}
-    flow_out = {pid: 0 for pid in plate_ids}
-    for c in cuts_used:
-        cnt = c.get('count', 0)
-        parent = c.get('parent_plate_id')
-        c1 = c.get('child1_plate_id')
-        c2 = c.get('child2_plate_id')
-        if parent is not None:
-            flow_out[parent] = flow_out.get(parent, 0) + cnt
-        if c1 is not None:
-            flow_in[c1] = flow_in.get(c1, 0) + cnt
-        if c2 is not None:
-            flow_in[c2] = flow_in.get(c2, 0) + cnt
-
-    # Constraint 1 (eq 2): flow balance for item plates j in J_bar, j != 0
-    for pid in plate_ids:
-        if pid == 0 or not in_J_bar.get(pid, False):
-            continue
-        fin = flow_in.get(pid, 0)
-        fout = flow_out.get(pid, 0)
-        yj = y_per_plate.get(pid, 0)
-        lhs = fin - fout - yj
-        if lhs < -TOL:
-            violated_constraints.add(1)
-            record_violation(violations, magnitudes, 1, lhs, 0.0,
-                             f"Constraint 1 (eq 2): plate {pid} flow balance "
-                             f"in({fin}) - out({fout}) - y({yj}) = {lhs} < 0")
-
-    # Constraint 2 (eq 3): flow balance for non-item plates j in J \\ J_bar
-    for pid in plate_ids:
-        if pid == 0 or in_J_bar.get(pid, False):
-            continue
-        fin = flow_in.get(pid, 0)
-        fout = flow_out.get(pid, 0)
-        lhs = fin - fout
-        if lhs < -TOL:
-            violated_constraints.add(2)
-            record_violation(violations, magnitudes, 2, lhs, 0.0,
-                             f"Constraint 2 (eq 3): plate {pid} flow balance "
-                             f"in({fin}) - out({fout}) = {lhs} < 0")
-
-    # Constraint 3 (eq 4): original panel (plate 0) used at most once
-    panel_lhs = flow_out.get(0, 0)
-    if in_J_bar.get(0, False):
-        panel_lhs += y_per_plate.get(0, 0)
-    if panel_lhs - 1 > TOL:
-        violated_constraints.add(3)
-        record_violation(violations, magnitudes, 3, panel_lhs, 1.0,
-                         f"Constraint 3 (eq 4): panel use {panel_lhs} > 1")
-
-    # ===================================================================
-    # Constraint 5 (eq 6): x variables non-negative integer
-    # Not directly checkable from solution (only y values provided).
-    # No violation recorded.
-    # ===================================================================
-
-    # ===================================================================
-    # Constraint 7 (Tier C, objective consistency):
-    #   The objective (eq 1)  max  sum_{j in J_bar} p_j * y_j  is a
-    #   deterministic function of the y variables alone, and the solution
-    #   carries every y variable (items_selected -> copies). We therefore
-    #   recompute the true objective exactly and reject as infeasible when
-    #   the program's self-reported objective_value disagrees beyond a
-    #   tight tolerance. This defends against LLM score-gaming exploits
-    #   that fabricate objective_value (e.g. 0 or sys.float_info.max).
-    #
-    #   Full recompute applies because no x / second-stage variable enters
-    #   the objective -- p_j * y_j depends only on the items kept.
-    #
-    #   The check is skipped (rather than firing a false positive) when the
-    #   solution references an unknown item type: the recompute cannot be
-    #   trusted, and such a solution is already infeasible via constraint 6,
-    #   so no verdict is lost.
-    # ===================================================================
-    reported_obj = solution.get('objective_value')
-    if reported_obj is not None:
-        obj_checkable = True
-        reported = None
-        true_obj = 0.0
-        try:
-            reported = float(reported_obj)
-            for iid, total_copies in y_per_item.items():
-                if iid not in item_by_id:
-                    obj_checkable = False
-                    break
-                true_obj += float(item_by_id[iid]['profit']) * float(total_copies)
-        except (TypeError, ValueError):
-            obj_checkable = False
-
-        if obj_checkable and reported is not None:
-            abs_diff = abs(reported - true_obj)
-            # The objective is an integer (sum of integer profits times
-            # integer copies); doubles represent it exactly at this scale.
-            # Absolute floor 0.5 catches any integer-level mismatch; the
-            # relative term guards huge objectives against solver float noise.
-            tol = max(0.5, 1e-6 * abs(true_obj))
-            if abs_diff > tol:
-                violated_constraints.add(7)
-                record_violation(violations, magnitudes, 7, reported, true_obj,
-                                 f"Constraint 7 (objective consistency): reported "
-                                 f"objective_value={reported} differs from recomputed "
-                                 f"sum_j(p_j*y_j)={true_obj} "
-                                 f"(|diff|={abs_diff:.6g}, tol={tol:.6g})")
-
-    # Build final result
-    violated_list = sorted(violated_constraints)
-    feasible = len(violated_list) == 0
-
-    return feasible, violated_list, violations, magnitudes
+    try:
+        if not isinstance(solution, dict):
+            raise ValueError("solution must be an object")
+        for name in ("items_selected", "plates", "cuts_used"):
+            if name not in solution or not isinstance(solution[name], list):
+                raise ValueError(f"Missing or invalid required cutting witness field '{name}'")
+        L = integer(instance['panel']['length'], 'panel.length', 1)
+        W = integer(instance['panel']['width'], 'panel.width', 1)
+        items = {integer(it['id'], 'item.id'): it for it in instance['items']}
+        plates = {}
+        for entry in solution['plates']:
+            if not isinstance(entry, dict):
+                raise ValueError('Each plate must be an object')
+            pid = integer(entry['id'], 'plate.id')
+            if pid in plates:
+                raise ValueError(f'Duplicate plate id {pid}')
+            length = integer(entry['length'], 'plate.length', 1)
+            width = integer(entry['width'], 'plate.width', 1)
+            if length > L or width > W:
+                raise ValueError(f'Plate {pid} exceeds trusted panel dimensions')
+            plates[pid] = (length, width)
+        if plates.get(0) != (L, W):
+            raise ValueError('Plate 0 must equal the trusted input panel dimensions')
+
+        used = defaultdict(int)
+        per_item = defaultdict(int)
+        selected_area = 0
+        objective = 0
+        for entry in solution['items_selected']:
+            if not isinstance(entry, dict):
+                raise ValueError('Each selected item must be an object')
+            iid = integer(entry['item_id'], 'item_id')
+            if iid not in items:
+                raise ValueError(f'Unknown item id {iid}')
+            count = integer(entry['copies'], 'item copies')
+            pid = integer(entry['plate_id'], 'selected plate_id')
+            item = items[iid]
+            expected = (integer(item['length'], 'item.length', 1),
+                        integer(item['width'], 'item.width', 1))
+            raw_dims = entry['plate_dims']
+            if not isinstance(raw_dims, list) or len(raw_dims) != 2:
+                raise ValueError('plate_dims must contain two integer dimensions')
+            dims = tuple(integer(v, 'plate_dims', 1) for v in raw_dims)
+            if dims != expected or plates.get(pid) != expected:
+                raise ValueError(f'Item {iid} must reference a declared plate matching its trusted dimensions')
+            used[pid] += count
+            per_item[iid] += count
+            selected_area += expected[0] * expected[1] * count
+            objective += integer(item['profit'], 'item.profit', 1) * count
+        for iid, count in per_item.items():
+            if count > integer(items[iid]['copies'], 'available copies'):
+                reject(f'Item {iid} selects {count} copies above the input bound', 4)
+        if selected_area > L * W:
+            reject(f'Selected item area {selected_area} exceeds panel area {L * W}', 3)
+
+        incoming = defaultdict(int)
+        outgoing = defaultdict(int)
+        for cut in solution['cuts_used']:
+            if not isinstance(cut, dict):
+                raise ValueError('Each cut must be an object')
+            parent = integer(cut['parent_plate_id'], 'parent_plate_id')
+            if parent not in plates:
+                raise ValueError(f'Unknown parent plate {parent}')
+            count = integer(cut['count'], 'cut count', 1)
+            pos = integer(cut['position'], 'cut position', 1)
+            length, width = plates[parent]
+            orientation = cut['orientation']
+            if orientation == 'h' and pos < width:
+                expected = [(length, pos), (length, width - pos)]
+            elif orientation == 'v' and pos < length:
+                expected = [(pos, width), (length - pos, width)]
+            else:
+                raise ValueError('Cut orientation/position must split the parent strictly inside its dimensions')
+            for field, dims in zip(('child1_plate_id', 'child2_plate_id'), expected):
+                if field not in cut:
+                    raise ValueError(f'Missing cut field {field}; use null for discarded material')
+                raw_child = cut[field]
+                if raw_child is None:
+                    continue  # Discarded residual material cannot provide items.
+                child = integer(raw_child, field)
+                if child not in plates or plates[child] != dims:
+                    raise ValueError(f'{field} dimensions do not match the trusted cut geometry')
+                incoming[child] += count
+            outgoing[parent] += count
+
+        # Never trust candidate in_J_bar flags: every selected item consumes
+        # a plate, including items matching the complete input panel.
+        if outgoing[0] + used[0] > 1:
+            reject('Original panel is consumed more than once', 3)
+        if incoming[0] != 0:
+            reject('Cuts cannot produce the original panel', 3)
+        for pid in plates:
+            if pid != 0 and outgoing[pid] + used[pid] > incoming[pid]:
+                reject(f'Plate {pid} consumes {outgoing[pid] + used[pid]} copies but only {incoming[pid]} are produced', 1)
+
+        reported = solution.get('objective_value')
+        if isinstance(reported, bool) or not isinstance(reported, (int, float)):
+            raise ValueError('objective_value must be a finite number')
+        if isinstance(reported, float) and not math.isfinite(reported):
+            raise ValueError('objective_value must be finite')
+        if not math.isclose(reported, objective, rel_tol=1e-9, abs_tol=1e-6):
+            reject(f'Reported objective {reported} differs from trusted recomputed profit {objective}', 7)
+    except (KeyError, TypeError, ValueError, OverflowError) as exc:
+        reject(f'Invalid cutting witness: {exc}')
+
+    return not violations, sorted(constraints), violations, magnitudes
 
 
 def main():

tasks/furini2016/mathematical_formulation.md

@@ -55,3 +55,7 @@ $$\begin{align}
   &x^o_{qj} \;\ge\; 0\ \text{integer}, && j\in J,\ o\in O,\ q\in Q(j,o) \tag{6}\\[4pt]
   &y_j \;\ge\; 0\ \text{integer}, && j\in\bar J \tag{7}
 \end{align}$$
+
+## Output witness convention
+
+Report the integer x and y witness as `cuts_used`, `plates`, and `items_selected` with `plate_id`, as detailed in solution_schema.json. Plate 0 is the trusted input panel. Horizontal cuts split width; vertical cuts split length, always at a strictly internal positive integer position. Null children discard residuals. Geometrically validated cuts strictly decrease plate area, so the plate flow is acyclic. For every nonroot plate, produced copies must cover cut consumption plus retained items; root consumption is at most one. These checks provide a constructive guillotine cutting witness without invoking an optimizer. The selected item area must also not exceed panel area; this necessary check alone is not sufficient.

tasks/furini2016/problem_description.txt

@@ -7,3 +7,5 @@ All cuts must be guillotine cuts, meaning each cut is a straight line that runs
 The cutting process works as follows. The original panel is the initial plate. Any plate may be split by a single guillotine cut into two smaller plates. Each of those smaller plates may in turn be split again, and so on recursively. A plate whose dimensions exactly match those of some item type may instead be kept as a finished item rather than being cut further. Any plate that is too small to contain any item is discarded. The process continues until every remaining plate has either been kept as an item or discarded.
 
 The manufacturer must decide how to recursively cut the original panel and which resulting item-sized plates to retain as finished items. The number of finished items of each type kept cannot exceed that type's maximum available copies. The quantity to maximize is the sum over all retained items of the item's profit times the number of copies retained.
+
+Output feasibility witness: provide the selected item counts together with a complete integer cutting-flow witness using the plates, cuts_used, and item plate_id fields defined in solution_schema.json. Plate 0 is the single input panel. Each cut consumes one parent plate and creates the two geometrically determined children; a null child ID discards that residual. Every selected copy consumes a plate with exactly the input item dimensions. The total number of cuts and selected copies consuming a plate type cannot exceed its produced count; the original panel can be consumed at most once. Plate type IDs may aggregate geometrically identical residuals. Candidate in_J_bar flags are unnecessary and are not trusted.

tasks/furini2016/solution_schema.json

@@ -4,7 +4,25 @@
     {
       "item_id": "<int> Identifier of the item type that is kept as a finished item.",
       "plate_dims": "<list[int], length 2> Length and width of the finished item kept.",
-      "copies": "<int> Number of finished copies retained of this item type."
+      "copies": "<int> Number of finished copies retained of this item type.",
+      "plate_id": "<int> ID of the declared plate consumed by these finished copies; its dimensions must equal the trusted item dimensions."
+    }
+  ],
+  "plates": [
+    {
+      "id": "<int> Unique nonnegative plate type ID. ID 0 must have the input panel dimensions. Only root and referenced plates need to be listed.",
+      "length": "<int> Positive integer length, at most panel.length.",
+      "width": "<int> Positive integer width, at most panel.width."
+    }
+  ],
+  "cuts_used": [
+    {
+      "parent_plate_id": "<int> Declared plate consumed by this cut.",
+      "orientation": "<str> 'h' splits width; 'v' splits length.",
+      "position": "<int> Strictly between zero and the split parent dimension.",
+      "child1_plate_id": "<int|null> First child plate ID, or null to discard it. For h its dimensions are (parent.length, position); for v (position, parent.width).",
+      "child2_plate_id": "<int|null> Second child plate ID, or null to discard it. For h its dimensions are (parent.length, parent.width-position); for v (parent.length-position, parent.width).",
+      "count": "<int> Positive integer number of times this cut is applied."
     }
   ]
 }