Nest task folders under tasks/ (part 9)

tasks/kang2021/instance_schema.json

@@ -0,0 +1,23 @@
+{
+  "num_customers": "<int> Number of customers to be served.",
+  "num_nodes": "<int> Total number of nodes including the depot and all customers.",
+  "parameters": {
+    "truck_speed": "<float> Travel speed of the truck.",
+    "truck_service_time": "<int> Time the truck spends servicing at each visited customer location.",
+    "num_drones": "<int> Number of drones carried by the truck.",
+    "drone_speed_parameters_alpha": "<list[float], length num_drones> Speed parameter for each drone, where higher values indicate faster but more energy-consuming drones.",
+    "drone_battery_capacities": "<list[int], length num_drones> Maximum total battery energy available to each drone across all its assigned deliveries.",
+    "standard_drone_speed": "<float> Travel speed of the baseline standard drone.",
+    "standard_drone_flight_duration": "<int> Maximum flight duration of the baseline standard drone.",
+    "standard_drone_service_time": "<int> Time a drone spends servicing at each customer location."
+  },
+  "depot_index": "<int> Index of the depot node where the truck starts and ends its route.",
+  "customer_indices": "<list[int], length num_customers> Indices of all customer nodes that must be served.",
+  "node_positions": {
+    "x": "<list[int], length num_nodes> Horizontal coordinate of each node.",
+    "y": "<list[int], length num_nodes> Vertical coordinate of each node."
+  },
+  "truck_travel_times": "<list[list[int]], shape [num_nodes][num_nodes]> Truck travel time from each node to every other node, including service time at the destination.",
+  "drone_battery_consumption": "<list[list[list[int]]], shape [num_drones][num_nodes][num_nodes]> Battery energy consumed by each drone for a round-trip delivery from a launch node to a customer and back.",
+  "drone_delivery_time": "<list[list[list[int]]], shape [num_drones][num_nodes][num_nodes]> Elapsed time for each drone to complete a round-trip delivery from a launch node to a customer and back."
+}

tasks/kang2021/mathematical_formulation.md

@@ -0,0 +1,67 @@
+# Original Formulation: Heterogeneous Drone-Truck Routing Problem (HDTRP)
+
+*Source: An Exact Algorithm for Heterogeneous Drone-Truck Routing Problem, Munjeong Kang and Chungmok Lee, Transportation Science 55(5):1088–1112, 2021.*
+
+## Sets and Indices
+
+- $N$ : set of customers.
+
+- $d$ : the (single) depot node, duplicated into two identical nodes $s$ and $t$.
+
+- $s,\, t$ : duplicated depot nodes ($s$ = origin/start, $t$ = destination/end); both represent the physical depot $d$.
+
+- $N_s := N \cup \{s\}$.
+
+- $N_t := N \cup \{t\}$.
+
+- $N_{st} := N \cup \{s, t\}$.
+
+- $G(N_{st}, A)$ : directed graph.
+
+- $A := \{(i,j) \mid i \in N_s,\, j \in N_t,\, i \neq j\}$ : set of arcs.
+
+- $L$ : set of drones.
+
+## Parameters
+
+- $t^v_{ij}$ : truck travel time of arc $(i,j) \in A$ (includes the service time at node $j$).
+
+- $B^l$ : battery capacity of drone $l \in L$ (how long the drone can be used for deliveries).
+
+- $b^l_{ij}$ : total battery consumption required for drone $l \in L$ to complete the delivery operation from waiting node $i \in N_s$ for the demand of customer $j \in N$.
+
+- $\tau^l_{ij}$ : total required time for drone $l \in L$ to complete the delivery from $i$ to $j$.
+
+- $M$ : a sufficiently large number (big-$M$).
+
+## Decision Variables
+
+- $x_{ij} \in \{0,1\}$ : $1$ if the truck moves from $i$ to $j$, $0$ otherwise, $\forall (i,j) \in A$.
+
+- $h^l_{ij} \in \{0,1\}$ : $1$ if drone $l \in L$ is dispatched at node $i$ for the delivery of customer $j$, $0$ otherwise, $\forall (i,j) \in A$.
+
+- $v_i$ : continuous variable representing the visiting order of the truck at node $i$.
+
+- $w_i$ : continuous variable representing the truck waiting time at node $i$.
+
+## Objective
+
+$$\begin{equation}
+  \text{(P)} \quad \min \ \sum_{(i,j) \in A} t^v_{ij}\, x_{ij} \;+\; \sum_{i \in N_s} w_i \tag{1}
+\end{equation}$$
+
+## Constraints
+
+$$\begin{align}
+  & \sum_{j \in N} x_{sj} = 1, \tag{2}\\[2pt]
+  & \sum_{i \in N} x_{it} = 1, \tag{3}\\[2pt]
+  & \sum_{j \in N_t:\, j \neq i} x_{ij} = \sum_{j \in N_s:\, j \neq i} x_{ji}, && \forall\, i \in N, \tag{4}\\[2pt]
+  & v_i - v_j \leq M(1 - x_{ij}) - 1, && \forall\, (i,j) \in A, \tag{5}\\[2pt]
+  & \sum_{i \in N_s:\, i \neq j} x_{ij} + \sum_{i \in N_s:\, i \neq j} \sum_{l \in L} h^l_{ij} = 1, && \forall\, j \in N, \tag{6}\\[2pt]
+  & M \sum_{j \in N_t:\, j \neq i} x_{ij} \geq \sum_{j \in N:\, j \neq i} \sum_{l \in L} h^l_{ij}, && \forall\, i \in N_s, \tag{7}\\[2pt]
+  & \sum_{i \in N_s} \sum_{j \in N:\, j \neq i} b^l_{ij}\, h^l_{ij} \leq B^l, && \forall\, l \in L, \tag{8}\\[2pt]
+  & w_i \geq \sum_{j \in N:\, j \neq i} \tau^l_{ij}\, h^l_{ij}, && \forall\, i \in N_s,\, l \in L, \tag{9}\\[2pt]
+  & v_s = 0, \tag{10}\\[2pt]
+  & x_{ij} \in \{0,1\}, && \forall\, (i,j) \in A, \tag{11}\\[2pt]
+  & h^l_{ij} \in \{0,1\}, && \forall\, (i,j) \in A,\, l \in L. \tag{12}
+\end{align}$$

tasks/kang2021/problem_description.txt

@@ -0,0 +1,11 @@
+# Problem Description
+
+A delivery company operates a single truck equipped with a fleet of heterogeneous drones to serve a set of customers from a single depot. Each drone has its own speed parameter and battery capacity, meaning faster drones consume more energy per unit distance and consequently have shorter maximum flight durations. The truck departs from the depot, visits a subset of customer locations along a route, and returns to the depot. At any node the truck visits, one or more drones may be dispatched simultaneously to serve nearby customers. A drone delivery from a given node consists of a round trip: the drone flies from the truck's current location to the assigned customer, delivers the demand, and returns to the same node. Each drone carries exactly one customer's demand per trip but may make multiple such round trips from the same or different nodes over the course of the route, provided its total battery consumption across all assigned deliveries does not exceed its battery capacity. While drones are out making deliveries, the truck must wait at the dispatch node until every drone dispatched from that node has returned; only then may the truck proceed to its next stop.
+
+The input data specifies the number of customers, the number of drones, the two-dimensional coordinates of the depot and all customers, the truck travel time for every ordered pair of nodes (which includes the service time at the destination node), and for each drone and every ordered pair of a potential launch node and a customer, both the total battery consumption and the total elapsed time for the round-trip delivery. Each drone's battery capacity is also given.
+
+The company must determine the truck's route through a subset of customer locations starting and ending at the depot, which customers are served directly by the truck along its route versus served by a drone, and for each drone-served customer, from which node the drone is launched and which specific drone performs the delivery. The truck's waiting time at each visited node must also be determined.
+
+Every customer must be served exactly once, either by the truck visiting that customer directly on its route or by exactly one drone making a delivery to that customer from some node on the truck's route. Drones may only be dispatched from nodes that the truck actually visits. The truck's route must form a single connected tour from the depot through the truck-visited customers and back to the depot, and no customer appears more than once on the truck's route (customers served by drones are not visited by the truck at all). The total battery consumed by each drone across all of its assigned deliveries must not exceed that drone's battery capacity. The truck's waiting time at each node must be at least as large as the combined round-trip delivery time of each drone for all deliveries that drone performs from that node. Because this must hold for every drone independently, the truck effectively waits for whichever drone has the longest total delivery time from that node before departing.
+
+The goal is to minimize the total completion time, defined as the sum of the truck's travel times along all arcs of its route plus the sum of the truck's waiting times at all nodes it visits.

tasks/kang2021/solution_logger.py

@@ -0,0 +1,61 @@
+"""
+Convergence logger for optimization algorithms.
+
+Records incumbent solutions with timestamps to a JSONL file.
+This module is provided to LLM-generated programs — they only need to call
+`log(objective_value)` whenever a better feasible solution is found.
+
+Usage in generated code:
+    from solution_logger import SolutionLogger
+    logger = SolutionLogger(log_path, sense="minimize")  # or "maximize"
+    # ... inside algorithm loop:
+    logger.log(objective_value)
+"""
+
+import json
+import time
+
+
+class SolutionLogger:
+    def __init__(self, log_path, sense="minimize"):
+        """
+        Args:
+            log_path: Path to the JSONL output file.
+            sense: "minimize" or "maximize".
+        """
+        self.log_path = log_path
+        self.sense = sense
+        self.start_time = time.time()
+        self.best_obj = None
+        self.min_interval = 0.1  # seconds, avoid excessive writes
+
+        self._last_log_time = 0.0
+        # Clear the file
+        with open(self.log_path, "w") as f:
+            pass
+
+    def log(self, objective_value):
+        """Record a new incumbent if it improves on the best known."""
+        if objective_value is None:
+            return
+
+        # Check if this is an improvement
+        if self.best_obj is not None:
+            if self.sense == "minimize" and objective_value >= self.best_obj:
+                return
+            if self.sense == "maximize" and objective_value <= self.best_obj:
+                return
+
+        elapsed = time.time() - self.start_time
+
+        # Throttle writes
+        if self.best_obj is not None and elapsed - self._last_log_time < self.min_interval:
+            self.best_obj = objective_value
+            return
+
+        self.best_obj = objective_value
+        self._last_log_time = elapsed
+
+        with open(self.log_path, "a") as f:
+            f.write(json.dumps({"time": round(elapsed, 3),
+                                "objective_value": objective_value}) + "\n")

tasks/kang2021/solution_schema.json

@@ -0,0 +1,9 @@
+{
+  "objective_value": "<float> Total completion time, comprising the truck's travel time along its route plus all waiting times at visited nodes.",
+  "truck_route": "<list[list[int]], shape [num_arcs][2]> Arcs traversed by the truck, where each entry is a pair of origin and destination node indices forming the route from depot to depot.",
+  "drone_assignments": "<list[dict]> Drone-to-customer delivery assignments, where each entry specifies which drone delivers to which customer from which node on the truck's route.",
+  "drone_assignments[*].drone": "<int> Index of the drone performing this delivery.",
+  "drone_assignments[*].dispatch_node": "<int> Node on the truck's route from which the drone is launched for this delivery.",
+  "drone_assignments[*].delivery_node": "<int> Customer node served by the drone on this delivery.",
+  "waiting_times": "<dict, key: '{node}'> Time the truck waits at each visited node for all dispatched drones to return."
+}

tasks/klose2005/feasibility_check.py

@@ -0,0 +1,466 @@
+"""
+Feasibility checker for the Capacitated Facility Location Problem (CFLP).
+
+Reference: Klose & Drexl (2005), "Lower Bounds for the Capacitated Facility
+Location Problem Based on Column Generation", Management Science 51(11):1689-1705.
+
+Constraints (numbered top-to-bottom from the formulation):
+  (1) Demand:      sum_j x_{ij} = 1            for all i in I
+  (2) Capacity:    sum_i d_i x_{ij} <= s_j y_j  for all j in J
+  (3) Var bounds:  0 <= x_{ij} <= 1             for all i in I, j in J
+  (4) Var bounds:  0 <= y_j <= 1                for all j in J
+  (5) Integrality: y_j in {0, 1}               for all j in J
+  (6) Objective consistency: the reported objective_value must equal the
+      objective recomputed from the solution variables,
+      Z = sum_{i,j} c_{ij} x_{ij} + sum_j f_j y_j.
+      This is a Tier C defense against score-gaming exploits where a
+      candidate returns a fabricated objective_value while the routes /
+      assignments remain technically feasible. Both x_{ij} and y_j are
+      fully present in the solution, so a full recompute is possible.
+"""
+
+import argparse
+import json
+import math
+
+# FRONTIEROR_RELEASE_CONTRACT_V2
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('assignments', 'objective_value', 'open_plants')
+_FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ()
+_FRONTIEROR_DERIVED_FIELD_RULES = ()
+_FRONTIEROR_CONDITIONAL_FIELD_RULES = ()
+
+
+def _frontieror_validate_solution_contract(solution):
+    """Return a structured rejection when the public solution contract is absent."""
+    violations = []
+    if not isinstance(solution, dict):
+        violations.append("solution must be a JSON object")
+    else:
+        missing = [
+            field
+            for field in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS
+            if field not in solution or solution[field] is None
+        ]
+        if missing:
+            violations.append(
+                "missing required solution field(s): " + ", ".join(missing)
+            )
+
+        for discriminator, expected_value, fields in _FRONTIEROR_CONDITIONAL_FIELD_RULES:
+            if solution.get(discriminator) != expected_value:
+                continue
+            conditional_missing = [
+                field
+                for field in fields
+                if field not in solution or solution[field] is None
+            ]
+            if conditional_missing:
+                violations.append(
+                    "missing conditionally required solution field(s): "
+                    + ", ".join(conditional_missing)
+                )
+
+        empty = [
+            field
+            for field in _FRONTIEROR_NONEMPTY_SOLUTION_FIELDS
+            if field in solution and solution[field] in (None, [], {})
+        ]
+        if empty:
+            violations.append(
+                "empty required decision witness field(s): " + ", ".join(empty)
+            )
+
+        for target, operation, source, source_key in _FRONTIEROR_DERIVED_FIELD_RULES:
+            try:
+                reported = float(solution[target])
+                if operation == "length":
+                    expected = float(len(solution[source]))
+                elif operation == "mapping_value":
+                    expected = float(solution[source][source_key])
+                else:
+                    raise ValueError("unknown derived-field operation")
+            except (KeyError, TypeError, ValueError, OverflowError):
+                violations.append(
+                    f"cannot derive {target} from decision witness field {source}"
+                )
+                continue
+            if (
+                reported != reported
+                or expected != expected
+                or reported in (float("inf"), float("-inf"))
+                or expected in (float("inf"), float("-inf"))
+                or abs(reported - expected) > 1e-6
+            ):
+                violations.append(
+                    f"{target}={reported} does not match the decision-derived "
+                    f"value {expected}"
+                )
+
+        if "objective_value" in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS:
+            objective = solution.get("objective_value")
+            if (
+                isinstance(objective, bool)
+                or not isinstance(objective, (int, float))
+                or objective != objective
+                or objective in (float("inf"), float("-inf"))
+            ):
+                violations.append("objective_value must be a finite JSON number")
+
+    if not violations:
+        return None
+    return {
+        "feasible": False,
+        "violated_constraints": ["solution_schema"],
+        "violations": violations,
+        "violation_magnitudes": [],
+    }
+
+
+def _frontieror_write_unexpected_rejection(error):
+    """Turn malformed candidate/checker exceptions into a normal rejection."""
+    import json as _frontieror_json
+    import sys as _frontieror_sys
+
+    result_path = None
+    for index, argument in enumerate(_frontieror_sys.argv):
+        if argument == "--result_path" and index + 1 < len(_frontieror_sys.argv):
+            result_path = _frontieror_sys.argv[index + 1]
+            break
+        if argument.startswith("--result_path="):
+            result_path = argument.split("=", 1)[1]
+            break
+    if not result_path:
+        return False
+    try:
+        with open(result_path, "w") as result_handle:
+            _frontieror_json.dump(
+                {
+                    "feasible": False,
+                    "violated_constraints": ["malformed_solution"],
+                    "violations": [
+                        "checker rejected malformed candidate: "
+                        + type(error).__name__
+                        + ": "
+                        + str(error)[:500]
+                    ],
+                    "violation_magnitudes": [],
+                },
+                result_handle,
+                indent=2,
+            )
+    except Exception:
+        return False
+    return True
+
+
+TOL = 1e-5
+EPS = 1e-5
+
+
+def load_json(path):
+    with open(path, "r") as f:
+        return json.load(f)
+
+
+def check_feasibility(instance, solution):
+    n_cust = instance["num_customers"]
+    n_plant = instance["num_plants"]
+    demands = instance["customers"]["demands"]
+    capacities = instance["plants"]["capacities"]
+
+    open_plants = set(solution["open_plants"])
+    assignments = solution["assignments"]
+
+    # Build y vector: y_j = 1 if j in open_plants, else 0
+    y = [1.0 if j in open_plants else 0.0 for j in range(n_plant)]
+
+    # Build x matrix from assignments (sparse dict of dicts)
+    # assignments is keyed by customer index (string) -> {plant_index (string): fraction}
+    x = [[0.0] * n_plant for _ in range(n_cust)]
+    for i_str, alloc in assignments.items():
+        i = int(i_str)
+        for j_str, val in alloc.items():
+            j = int(j_str)
+            x[i][j] = val
+
+    violated_constraints = set()
+    violations = []
+    violation_magnitudes = []
+
+    # =========================================================================
+    # Constraint (1): Demand  --  sum_j x_{ij} = 1  for all i in I
+    # =========================================================================
+    for i in range(n_cust):
+        lhs = sum(x[i][j] for j in range(n_plant))
+        rhs = 1.0
+        violation_amount = abs(lhs - rhs)
+        if violation_amount > TOL:
+            violated_constraints.add(1)
+            violations.append(
+                f"Constraint (1) violated: customer {i} demand fraction sum = {lhs:.8f}, expected 1.0"
+            )
+            normalizer = max(abs(rhs), EPS)
+            violation_magnitudes.append({
+                "constraint": 1,
+                "lhs": lhs,
+                "rhs": rhs,
+                "raw_excess": violation_amount,
+                "normalizer": normalizer,
+                "ratio": violation_amount / normalizer,
+            })
+
+    # =========================================================================
+    # Constraint (2): Capacity  --  sum_i d_i x_{ij} <= s_j y_j  for all j in J
+    # =========================================================================
+    for j in range(n_plant):
+        lhs = sum(demands[i] * x[i][j] for i in range(n_cust))
+        rhs = capacities[j] * y[j]
+        violation_amount = lhs - rhs  # positive when LHS > RHS
+        if violation_amount > TOL:
+            violated_constraints.add(2)
+            violations.append(
+                f"Constraint (2) violated: plant {j} load = {lhs:.8f} exceeds capacity {rhs:.8f}"
+            )
+            normalizer = max(abs(rhs), EPS)
+            violation_magnitudes.append({
+                "constraint": 2,
+                "lhs": lhs,
+                "rhs": rhs,
+                "raw_excess": violation_amount,
+                "normalizer": normalizer,
+                "ratio": violation_amount / normalizer,
+            })
+
+    # =========================================================================
+    # Constraint (3): Variable bounds on x  --  0 <= x_{ij} <= 1  for all i, j
+    # =========================================================================
+    for i in range(n_cust):
+        for j in range(n_plant):
+            val = x[i][j]
+            # Check lower bound: 0 <= x_{ij}  =>  x_{ij} >= 0
+            if val < -TOL:
+                violation_amount = -val  # how much below 0
+                violated_constraints.add(3)
+                violations.append(
+                    f"Constraint (3) violated: x[{i}][{j}] = {val:.8f} < 0"
+                )
+                rhs = 0.0
+                normalizer = max(abs(rhs), EPS)
+                violation_magnitudes.append({
+                    "constraint": 3,
+                    "lhs": val,
+                    "rhs": rhs,
+                    "raw_excess": violation_amount,
+                    "normalizer": normalizer,
+                    "ratio": violation_amount / normalizer,
+                })
+            # Check upper bound: x_{ij} <= 1
+            if val > 1.0 + TOL:
+                violation_amount = val - 1.0  # how much above 1
+                violated_constraints.add(3)
+                violations.append(
+                    f"Constraint (3) violated: x[{i}][{j}] = {val:.8f} > 1"
+                )
+                rhs = 1.0
+                normalizer = max(abs(rhs), EPS)
+                violation_magnitudes.append({
+                    "constraint": 3,
+                    "lhs": val,
+                    "rhs": rhs,
+                    "raw_excess": violation_amount,
+                    "normalizer": normalizer,
+                    "ratio": violation_amount / normalizer,
+                })
+
+    # =========================================================================
+    # Constraint (4): Variable bounds on y  --  0 <= y_j <= 1  for all j in J
+    # =========================================================================
+    for j in range(n_plant):
+        val = y[j]
+        if val < -TOL:
+            violation_amount = -val
+            violated_constraints.add(4)
+            violations.append(
+                f"Constraint (4) violated: y[{j}] = {val:.8f} < 0"
+            )
+            rhs = 0.0
+            normalizer = max(abs(rhs), EPS)
+            violation_magnitudes.append({
+                "constraint": 4,
+                "lhs": val,
+                "rhs": rhs,
+                "raw_excess": violation_amount,
+                "normalizer": normalizer,
+                "ratio": violation_amount / normalizer,
+            })
+        if val > 1.0 + TOL:
+            violation_amount = val - 1.0
+            violated_constraints.add(4)
+            violations.append(
+                f"Constraint (4) violated: y[{j}] = {val:.8f} > 1"
+            )
+            rhs = 1.0
+            normalizer = max(abs(rhs), EPS)
+            violation_magnitudes.append({
+                "constraint": 4,
+                "lhs": val,
+                "rhs": rhs,
+                "raw_excess": violation_amount,
+                "normalizer": normalizer,
+                "ratio": violation_amount / normalizer,
+            })
+
+    # =========================================================================
+    # Constraint (5): Integrality  --  y_j in {0, 1}  for all j in J
+    # =========================================================================
+    for j in range(n_plant):
+        val = y[j]
+        dist_to_int = min(abs(val - 0.0), abs(val - 1.0))
+        if dist_to_int > TOL:
+            violated_constraints.add(5)
+            violations.append(
+                f"Constraint (5) violated: y[{j}] = {val:.8f} is not binary"
+            )
+            # For integrality, LHS is the value, RHS is nearest integer
+            nearest_int = round(val)
+            rhs = float(nearest_int)
+            violation_amount = abs(val - rhs)
+            normalizer = max(abs(rhs), EPS)
+            violation_magnitudes.append({
+                "constraint": 5,
+                "lhs": val,
+                "rhs": rhs,
+                "raw_excess": violation_amount,
+                "normalizer": normalizer,
+                "ratio": violation_amount / normalizer,
+            })
+
+    # =========================================================================
+    # Constraint (6): Objective consistency  --  the reported objective_value
+    # must equal the objective recomputed from the solution variables:
+    #     Z = sum_{i,j} c_{ij} x_{ij} + sum_j f_j y_j
+    # where c_{ij} = shipping_costs[i][j] (cost of supplying ALL of customer
+    # i's demand from plant j, so c_{ij} x_{ij} already accounts for demand)
+    # and f_j = plants.fixed_costs[j]. Both x_{ij} and y_j are present in the
+    # solution, so this is an exact full recompute. A 0.1% relative tolerance
+    # (with a 1e-3 absolute floor) absorbs floating-point accumulation while
+    # still rejecting fabricated objective values (e.g. 0 or float-max).
+    # =========================================================================
+    fixed_costs = instance["plants"]["fixed_costs"]
+    shipping_costs = instance["shipping_costs"]
+    reported_obj = solution.get("objective_value")
+    if reported_obj is not None:
+        try:
+            reported = float(reported_obj)
+        except (TypeError, ValueError):
+            reported = None
+        if reported is not None and math.isfinite(reported):
+            shipping_total = 0.0
+            for i in range(n_cust):
+                row = shipping_costs[i]
+                xrow = x[i]
+                for j in range(n_plant):
+                    xv = xrow[j]
+                    if xv != 0.0:
+                        shipping_total += row[j] * xv
+            fixed_total = sum(fixed_costs[j] * y[j] for j in range(n_plant))
+            true_obj = shipping_total + fixed_total
+            violation_amount = abs(reported - true_obj)
+            tol = max(1e-3, 1e-3 * abs(true_obj))
+            if violation_amount > tol:
+                violated_constraints.add(6)
+                violations.append(
+                    f"Constraint (6) violated: reported objective_value = {reported:.8f} "
+                    f"differs from recomputed total cost {true_obj:.8f} "
+                    f"(|diff| = {violation_amount:.6g}, tol = {tol:.6g})"
+                )
+                rhs = true_obj
+                normalizer = max(abs(rhs), EPS)
+                violation_magnitudes.append({
+                    "constraint": 6,
+                    "lhs": reported,
+                    "rhs": rhs,
+                    "raw_excess": violation_amount,
+                    "normalizer": normalizer,
+                    "ratio": violation_amount / normalizer,
+                })
+        elif reported is not None:
+            # Non-finite reported objective (inf / nan) can never match a
+            # finite recomputed cost -- treat as an objective inconsistency.
+            shipping_total = 0.0
+            for i in range(n_cust):
+                row = shipping_costs[i]
+                xrow = x[i]
+                for j in range(n_plant):
+                    xv = xrow[j]
+                    if xv != 0.0:
+                        shipping_total += row[j] * xv
+            fixed_total = sum(fixed_costs[j] * y[j] for j in range(n_plant))
+            true_obj = shipping_total + fixed_total
+            violated_constraints.add(6)
+            violations.append(
+                f"Constraint (6) violated: reported objective_value = {reported} "
+                f"is not finite; recomputed total cost = {true_obj:.8f}"
+            )
+            normalizer = max(abs(true_obj), EPS)
+            violation_magnitudes.append({
+                "constraint": 6,
+                "lhs": reported,
+                "rhs": true_obj,
+                "raw_excess": float("inf"),
+                "normalizer": normalizer,
+                "ratio": float("inf"),
+            })
+
+    feasible = len(violated_constraints) == 0
+    result = {
+        "feasible": feasible,
+        "violated_constraints": sorted(violated_constraints),
+        "violations": violations,
+        "violation_magnitudes": violation_magnitudes,
+    }
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Feasibility checker for the Capacitated Facility Location Problem (CFLP)."
+    )
+    parser.add_argument("--instance_path", required=True, help="Path to the instance JSON file.")
+    parser.add_argument("--solution_path", required=True, help="Path to the solution JSON file.")
+    parser.add_argument("--result_path", required=True, help="Path to write the feasibility result JSON file.")
+    args = parser.parse_args()
+
+    instance = load_json(args.instance_path)
+    solution = load_json(args.solution_path)
+    _frontieror_contract_result = _frontieror_validate_solution_contract(solution)
+    if _frontieror_contract_result is not None:
+        with open(args.result_path, "w") as _frontieror_result_handle:
+            json.dump(
+                _frontieror_contract_result,
+                _frontieror_result_handle,
+                indent=2,
+            )
+        return
+
+    result = check_feasibility(instance, solution)
+
+    with open(args.result_path, "w") as f:
+        json.dump(result, f, indent=2)
+
+    if result["feasible"]:
+        print("Solution is FEASIBLE.")
+    else:
+        print(f"Solution is INFEASIBLE. Violated constraints: {result['violated_constraints']}")
+        for v in result["violations"]:
+            print(f"  - {v}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as _frontieror_unexpected_error:
+        if not _frontieror_write_unexpected_rejection(
+            _frontieror_unexpected_error
+        ):
+            raise

tasks/klose2005/gurobi_code.py

@@ -0,0 +1,183 @@
+"""
+Gurobi MIP implementation of the Capacitated Facility Location Problem (CFLP).
+
+Reference: Klose & Drexl (2005), "Lower Bounds for the Capacitated Facility
+Location Problem Based on Column Generation", Management Science 51(11):1689-1705.
+
+The model:
+    min  sum_{i,j} c_{ij} x_{ij} + sum_j f_j y_j
+    s.t. sum_j x_{ij} = 1                for all i       (D) demand
+         sum_i d_i x_{ij} <= s_j y_j     for all j       (C) capacity
+         0 <= x_{ij} <= 1                for all i,j     (N)
+         y_j in {0,1}                    for all j       (I)
+
+Optionally, valid inequalities (B) x_{ij} <= y_j and (T) sum_j s_j y_j >= d^I
+are added as cuts to tighten the LP relaxation.
+"""
+
+import argparse
+import json
+import time
+import gurobipy as gp
+from gurobipy import GRB
+import os as _os, sys as _sys
+# Walk up from this file's directory to find repo root (containing scripts/).
+_GUROBI_CODE_START_TIME = time.time()
+_repo = _os.path.dirname(_os.path.abspath(__file__))
+while _repo != _os.path.dirname(_repo) and not _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _repo = _os.path.dirname(_repo)
+if _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _sys.path.insert(0, _repo)
+try:
+    from scripts.utils.gurobi_log_helper import install_gurobi_logger
+except ImportError:
+    def install_gurobi_logger(log_path):  # no-op fallback when scripts/ unavailable
+        pass
+
+
+def load_instance(path):
+    with open(path, "r") as f:
+        data = json.load(f)
+    return data
+
+
+def build_model(data, time_limit):
+    n_cust = data["num_customers"]
+    n_plant = data["num_plants"]
+    d = data["customers"]["demands"]
+    s = data["plants"]["capacities"]
+    f = data["plants"]["fixed_costs"]
+    c = data["shipping_costs"]  # c[i][j]
+    total_demand = sum(d)
+
+    I = range(n_cust)
+    J = range(n_plant)
+
+    model = gp.Model("CFLP")
+    model.setParam("Threads", 1)
+    model.setParam("TimeLimit", time_limit)
+    model.setParam("OutputFlag", 1)
+
+    # Decision variables
+    x = {}
+    for i in I:
+        for j in J:
+            x[i, j] = model.addVar(lb=0.0, ub=1.0, vtype=GRB.CONTINUOUS,
+                                   name=f"x_{i}_{j}")
+    y = {}
+    for j in J:
+        y[j] = model.addVar(vtype=GRB.BINARY, name=f"y_{j}")
+
+    model.update()
+
+    # Objective
+    model.setObjective(
+        gp.quicksum(c[i][j] * x[i, j] for i in I for j in J)
+        + gp.quicksum(f[j] * y[j] for j in J),
+        GRB.MINIMIZE
+    )
+
+    # (D) Demand constraints
+    for i in I:
+        model.addConstr(
+            gp.quicksum(x[i, j] for j in J) == 1,
+            name=f"demand_{i}"
+        )
+
+    # (C) Capacity constraints
+    for j in J:
+        model.addConstr(
+            gp.quicksum(d[i] * x[i, j] for i in I) <= s[j] * y[j],
+            name=f"capacity_{j}"
+        )
+
+    # (B) Variable upper bound constraints (valid inequality to tighten LP)
+    for i in I:
+        for j in J:
+            model.addConstr(x[i, j] <= y[j], name=f"vub_{i}_{j}")
+
+    # (T) Aggregate capacity constraint (valid inequality)
+    model.addConstr(
+        gp.quicksum(s[j] * y[j] for j in J) >= total_demand,
+        name="agg_capacity"
+    )
+
+    return model, x, y
+
+
+def solve_and_export(model, x, y, data, solution_path):
+    n_cust = data["num_customers"]
+    n_plant = data["num_plants"]
+
+    model.optimize()
+
+    result = {}
+    if model.SolCount > 0:
+        result["objective_value"] = model.ObjVal
+        result["best_bound"] = model.ObjBound
+        result["gap"] = model.MIPGap
+        result["status"] = model.Status
+        result["solve_time"] = model.Runtime
+
+        # Extract solution
+        y_sol = {}
+        for j in range(n_plant):
+            val = y[j].X
+            if val > 0.5:
+                y_sol[j] = 1
+        result["open_plants"] = sorted(y_sol.keys())
+
+        x_sol = {}
+        for i in range(n_cust):
+            assignments = {}
+            for j in range(n_plant):
+                val = x[i, j].X
+                if val > 1e-6:
+                    assignments[j] = val
+            x_sol[i] = assignments
+        result["assignments"] = {str(i): {str(j): v for j, v in assigns.items()}
+                                 for i, assigns in x_sol.items()}
+    else:
+        result["objective_value"] = None
+        result["status"] = model.Status
+        result["solve_time"] = model.Runtime
+
+    with open(solution_path, "w") as f:
+        result["runtime"] = time.time() - _GUROBI_CODE_START_TIME
+        json.dump(result, f, indent=2)
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Solve CFLP using Gurobi MIP (Klose & Drexl 2005)")
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to the JSON instance file")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path for the output solution JSON file")
+    parser.add_argument("--time_limit", type=int, required=True,
+                        help="Maximum solver runtime in seconds")
+    parser.add_argument("--log_path", type=str, default=None, help="Path to log incumbent solutions")
+    args = parser.parse_args()
+    install_gurobi_logger(args.log_path)
+
+    data = load_instance(args.instance_path)
+    print(f"Loaded instance: {data['num_customers']} customers x "
+          f"{data['num_plants']} plants, r={data['capacity_tightness_ratio']}")
+
+    model, x, y = build_model(data, args.time_limit)
+    result = solve_and_export(model, x, y, data, args.solution_path)
+
+    if result["objective_value"] is not None:
+        print(f"Objective value: {result['objective_value']:.4f}")
+        print(f"Best bound: {result['best_bound']:.4f}")
+        print(f"Gap: {result['gap']:.6f}")
+        print(f"Open plants: {len(result['open_plants'])}")
+    else:
+        print("No feasible solution found.")
+    print(f"Solve time: {result['solve_time']:.2f}s")
+
+
+if __name__ == "__main__":
+    main()

tasks/klose2005/gurobi_feasi_result/large_feasi_result_1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/klose2005/gurobi_feasi_result/large_feasi_result_2.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/klose2005/gurobi_feasi_result/large_feasi_result_3.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/klose2005/gurobi_feasi_result/large_feasi_result_4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/klose2005/gurobi_feasi_result/large_feasi_result_5.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/klose2005/gurobi_feasi_result/tiny_feasi_result.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/klose2005/gurobi_solution/large_solution_1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cef24f507fee51a8055b784944294dd323f6e812699767e86ecf2bfab8f96220
+size 69905

tasks/klose2005/gurobi_solution/large_solution_2.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d7e412b1e7e419b9ace55177ba1810936c04dab7084e6cf74ffd3e2611b01a8
+size 65836

tasks/klose2005/gurobi_solution/large_solution_3.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea3857a63df56db5e3a22505396365353dc4b7ecb9b5deab21adbffea8619a16
+size 69753

tasks/klose2005/gurobi_solution/large_solution_4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:900ef8dadffcea2fdb239d63f4486ca369d7e42c9e517a7f7e4607e2cbc74fb1
+size 69451

tasks/klose2005/gurobi_solution/large_solution_5.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90990a399f2143eaa01c9ef2e67e3d9195589d0f3a27ef0a3053040fb92b1bf6
+size 69935

tasks/klose2005/gurobi_solution/tiny_solution.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c5c4d4489a0a35eab782105aed47196d24e3c91f69de82d685a824375153ac9
+size 5392

tasks/klose2005/gurobi_solution_log/large_log_1.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a688d526c508e29621a67299c2a2e5f22f5e3b220cf5cd5d5ecb0d2858226241
+size 613

tasks/klose2005/gurobi_solution_log/large_log_2.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ada12b39d96613f2e0ddbdc82014a8aca16c432e33c8d6f124039b9d56c12cc1
+size 1859

tasks/klose2005/gurobi_solution_log/large_log_3.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d127f209c56cfdfd246cc75bc29033ecf9c3939c809552551a17f68b30dfbe2
+size 386

tasks/klose2005/gurobi_solution_log/large_log_4.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cdafeed8e880cf4ccbeacf3e385d46b52026ed89195ea57255535eeeefacdba
+size 720

tasks/klose2005/gurobi_solution_log/large_log_5.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ed6eada164ab0c369e8b545a4cf64cfeb5113f9dcdcf7edc8c394af65599fff
+size 727

tasks/klose2005/gurobi_solution_log/tiny_log.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3d6c7075223f98d74a6bae7021073454f4fd6a79b43dbd42ce2bf7dbbb99ea7
+size 541

tasks/klose2005/instance/large_instance_1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffe1dac206046cc68e2f307cce2631655e49b695b72328cde2ae02aea7381020
+size 17350517

tasks/klose2005/instance/large_instance_2.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4657041dac5b37033fe5651bec41f56a69610f1d102d288a0687de980f099c9
+size 17570617

tasks/klose2005/instance/large_instance_3.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70db76284dee72895ddc3fff307db6ec772b862775c2ca598a601db06ce96ef0
+size 16571343

tasks/klose2005/instance/large_instance_4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b632eef0938468716382ca6e54ecb4b8ade4e57999ff49b6a51209844165e33
+size 17612283

tasks/klose2005/instance/large_instance_5.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:534dea190879d91ac429e0b36d69aa9934754af021bf8b632692a1e7837ee93b
+size 17355457

tasks/klose2005/instance/tiny_instance.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2002dc3c96c39b21bf80e2db91c1de641f259c7a7653fa3d5efa6b664495c12a
+size 175678

tasks/klose2005/instance_schema.json

@@ -0,0 +1,19 @@
+{
+  "num_customers": "<int> Number of customers whose demands must be fulfilled.",
+  "num_plants": "<int> Number of candidate plant sites that may be opened.",
+  "capacity_tightness_ratio": "<int> Ratio of total plant capacity to total customer demand, controlling how tight capacity constraints are.",
+  "total_demand": "<int> Sum of all customer demands.",
+  "total_capacity": "<float> Sum of all plant capacities.",
+  "customers": {
+    "demands": "<list[int], length num_customers> Quantity of goods demanded by each customer.",
+    "x_coords": "<list[float], length num_customers> Horizontal coordinate of each customer's location.",
+    "y_coords": "<list[float], length num_customers> Vertical coordinate of each customer's location."
+  },
+  "plants": {
+    "fixed_costs": "<list[int], length num_plants> Fixed cost incurred for opening each candidate plant.",
+    "capacities": "<list[float], length num_plants> Maximum total demand each plant can serve if opened.",
+    "x_coords": "<list[float], length num_plants> Horizontal coordinate of each candidate plant's location.",
+    "y_coords": "<list[float], length num_plants> Vertical coordinate of each candidate plant's location."
+  },
+  "shipping_costs": "<list[list[float]], shape [num_customers][num_plants]> Cost of supplying a customer's entire demand from a given plant, proportional to demand and Euclidean distance."
+}

tasks/klose2005/mathematical_formulation.md

@@ -0,0 +1,37 @@
+# Sets and Parameters
+
+- $I$: set of customers, indexed by $i$.
+
+- $J$: set of potential plant (facility) locations, indexed by $j$.
+
+- $c_{ij} \geq 0$: cost of supplying all of customer $i$’s demand from $j$.
+
+- $f_j \geq 0$: fixed cost of opening facility $j$.
+
+- $d_i \geq 0$: demand of customer $i$.
+
+- $s_j > 0$: capacity of facility $j$ when open.
+
+- $d^{I} = \sum_{i \in I} d_i$: total demand. Assumed: $\sum_{j \in J} s_j > d^{I}$.
+
+# Decision Variables
+
+- $y_j \in \{0,1\}$ for $j \in J$: $=1$ iff facility $j$ is open.
+
+- $x_{ij} \in [0,1]$ for $i \in I,\ j \in J$: fraction of customer $i$’s demand met from $j$.
+
+# Formulation
+
+$$\begin{align}
+Z = \min \quad & \sum_{i \in I}\sum_{j \in J} c_{ij}\, x_{ij} + \sum_{j \in J} f_j\, y_j \\
+\text{s.t.}\quad & \sum_{j \in J} x_{ij} = 1,
+   && \forall i \in I, \tag{D}\\
+& \sum_{i \in I} d_i\, x_{ij} \leq s_j\, y_j,
+   && \forall j \in J, \tag{C}\\
+& 0 \leq x_{ij} \leq 1,
+   && \forall i \in I,\ j \in J, \tag{N}\\
+& y_j \in \{0,1\},
+   && \forall j \in J. \tag{I}
+\end{align}$$
+
+\(D\) enforces full demand satisfaction; (C) enforces capacity and links allocation to opening; (N) are bounds on the continuous allocation variables; (I) is integrality of the location variables.

tasks/klose2005/problem_description.txt

@@ -0,0 +1,7 @@
+# Problem Description
+
+A company must decide which plants to open from a set of potential facility locations and how to assign customers to those open plants in order to satisfy all customer demands at minimum total cost. There are a given number of customers and a given number of candidate plant sites. Each customer has a known non-negative demand, and each candidate plant has a known strictly positive capacity and a known non-negative fixed cost that is incurred if and only if that plant is opened. For every customer-plant pair, there is a known non-negative shipping cost that represents the cost of supplying that customer's entire demand from that plant. A customer's demand may be split across multiple open plants; specifically, any fraction of a customer's demand between zero and one hundred percent may be served by any single open plant, and the shipping cost for that plant-customer pair scales proportionally with the fraction served. The total capacity across all candidate plants strictly exceeds total customer demand, ensuring that a feasible supply plan exists.
+
+The company must make two types of choices: which plants to open and what fraction of each customer's demand to fulfill from each open plant. Every customer's demand must be met in full, meaning the fractions assigned to that customer across all plants must sum to exactly one. The total demand assigned to each open plant, computed as the sum over all customers of each customer's demand multiplied by the fraction of that demand assigned to the plant, must not exceed that plant's capacity. A closed plant cannot serve any customer at all.
+
+The goal is to minimize total cost, which is the sum of two components: total shipping cost, computed as the sum over all customer-plant pairs of the shipping cost times the fraction of that customer's demand served by that plant, and total fixed cost, computed as the sum of the fixed opening costs of all plants that are chosen to be opened.

tasks/klose2005/solution_logger.py

@@ -0,0 +1,61 @@
+"""
+Convergence logger for optimization algorithms.
+
+Records incumbent solutions with timestamps to a JSONL file.
+This module is provided to LLM-generated programs — they only need to call
+`log(objective_value)` whenever a better feasible solution is found.
+
+Usage in generated code:
+    from solution_logger import SolutionLogger
+    logger = SolutionLogger(log_path, sense="minimize")  # or "maximize"
+    # ... inside algorithm loop:
+    logger.log(objective_value)
+"""
+
+import json
+import time
+
+
+class SolutionLogger:
+    def __init__(self, log_path, sense="minimize"):
+        """
+        Args:
+            log_path: Path to the JSONL output file.
+            sense: "minimize" or "maximize".
+        """
+        self.log_path = log_path
+        self.sense = sense
+        self.start_time = time.time()
+        self.best_obj = None
+        self.min_interval = 0.1  # seconds, avoid excessive writes
+
+        self._last_log_time = 0.0
+        # Clear the file
+        with open(self.log_path, "w") as f:
+            pass
+
+    def log(self, objective_value):
+        """Record a new incumbent if it improves on the best known."""
+        if objective_value is None:
+            return
+
+        # Check if this is an improvement
+        if self.best_obj is not None:
+            if self.sense == "minimize" and objective_value >= self.best_obj:
+                return
+            if self.sense == "maximize" and objective_value <= self.best_obj:
+                return
+
+        elapsed = time.time() - self.start_time
+
+        # Throttle writes
+        if self.best_obj is not None and elapsed - self._last_log_time < self.min_interval:
+            self.best_obj = objective_value
+            return
+
+        self.best_obj = objective_value
+        self._last_log_time = elapsed
+
+        with open(self.log_path, "a") as f:
+            f.write(json.dumps({"time": round(elapsed, 3),
+                                "objective_value": objective_value}) + "\n")

tasks/klose2005/solution_schema.json

@@ -0,0 +1,5 @@
+{
+  "objective_value": "<float> Total cost of the solution, including fixed costs of opened plants and shipping costs from plants to customers.",
+  "open_plants": "<list[int]> Indices of the plants that are opened to serve customers.",
+  "assignments": "<dict[str, dict[str, float]], key: '{customer}' mapping to inner key '{plant}'> Fraction of each customer's demand supplied by each plant."
+}

tasks/knueven2020/feasibility_check.py

@@ -0,0 +1,693 @@
+#!/usr/bin/env python3
+"""
+Feasibility checker for the Unit Commitment (UC) problem.
+
+Paper: Knueven, Ostrowski, Watson (2020)
+       "On Mixed Integer Programming Formulations for the Unit Commitment Problem"
+
+Checks ORIGINAL 1-bin formulation constraints (the first concrete model the
+paper writes, Slide 4, with decision variables u, p, pb). The 3-bin
+auxiliaries v, w (startup/shutdown indicators) are NOT part of the
+original and are derived internally from u only when needed for
+min-up / min-down verification. Constraints:
+
+  1.  Power balance: sum_g p[g,t] = demand[t]
+  2.  [SKIPPED — 3-bin definitional linking u(t)-u(t-1)=v(t)-w(t)
+        is a reformulation artifact, not an original-1-bin constraint]
+  3.  Minimum up-time: via u consecutive-on-runs (derived v)
+  4.  Minimum down-time: via u consecutive-off-runs (derived w)
+  5.  Generation lower bound: p[g,t] >= p_min * u[g,t]
+  6.  Generation upper bound: pb[g,t] <= p_max * u[g,t]
+  7.  Power <= available: p[g,t] <= pb[g,t]
+  8.  Ramp-up: p[g,t] - p[g,t-1] <= RU * u[g,t-1] + SU * v[g,t]
+  9.  Ramp-down: p[g,t-1] - p[g,t] <= RD * u[g,t] + SD * w[g,t]
+  10. VUB inequality (Slide 10, when UT >= TRU + TRD + 2)
+  11. Piecewise cost sum feasibility: 0 <= p[g,t] - p_min*u[g,t] <= (p_max-p_min)*u[g,t]
+  12. Piecewise segment bound (requires pl variables - not in solution, skip)
+  13. Startup tier partition (requires delta variables - not in solution, skip)
+  14. Startup tier window (requires delta variables - not in solution, skip)
+  15. Reserve requirement: sum_g pb[g,t] >= demand[t] + reserve[t]
+  16. Binary constraints: u, v, w in {0, 1}
+  17. Non-negativity: p >= 0, pb >= 0
+  18. Initial up/down time obligations
+  19. Objective consistency (Tier C defense against score-gaming): the
+        self-reported objective_value must equal the cost recomputed from
+        the committed schedule. The objective is
+          min sum_g sum_t [ NL_g*u + sum_l f^l*pl + sum_k SC_k*delta ].
+        Since the piecewise-segment variables pl and the startup-tier
+        variables delta are cost-minimised auxiliaries (no constraint
+        binds them other than their definitions), they are fully
+        determined by (u, p): pl is the cheapest segment fill of
+        p-p_min*u, and delta picks the cheapest eligible startup tier.
+        This makes a FULL exact recompute possible from the solution's
+        u and p alone. A reported objective that disagrees with the
+        recompute (beyond a tight relative tolerance) is rejected.
+
+NOTE: feasibility_check_new.py adds only constraint 19 on top of the
+original feasibility_check.py; constraints 1-18 are byte-for-byte the
+original checks. The eval-pipeline JSON shape (feasible /
+violated_constraints / violations / violation_magnitudes) is unchanged.
+"""
+
+import argparse
+import json
+import math
+import sys
+
+# FRONTIEROR_RELEASE_CONTRACT_V2
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('objective_value', 'schedule')
+_FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ()
+_FRONTIEROR_DERIVED_FIELD_RULES = ()
+_FRONTIEROR_CONDITIONAL_FIELD_RULES = ()
+
+
+def _frontieror_validate_solution_contract(solution):
+    """Return a structured rejection when the public solution contract is absent."""
+    violations = []
+    if not isinstance(solution, dict):
+        violations.append("solution must be a JSON object")
+    else:
+        missing = [
+            field
+            for field in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS
+            if field not in solution or solution[field] is None
+        ]
+        if missing:
+            violations.append(
+                "missing required solution field(s): " + ", ".join(missing)
+            )
+
+        for discriminator, expected_value, fields in _FRONTIEROR_CONDITIONAL_FIELD_RULES:
+            if solution.get(discriminator) != expected_value:
+                continue
+            conditional_missing = [
+                field
+                for field in fields
+                if field not in solution or solution[field] is None
+            ]
+            if conditional_missing:
+                violations.append(
+                    "missing conditionally required solution field(s): "
+                    + ", ".join(conditional_missing)
+                )
+
+        empty = [
+            field
+            for field in _FRONTIEROR_NONEMPTY_SOLUTION_FIELDS
+            if field in solution and solution[field] in (None, [], {})
+        ]
+        if empty:
+            violations.append(
+                "empty required decision witness field(s): " + ", ".join(empty)
+            )
+
+        for target, operation, source, source_key in _FRONTIEROR_DERIVED_FIELD_RULES:
+            try:
+                reported = float(solution[target])
+                if operation == "length":
+                    expected = float(len(solution[source]))
+                elif operation == "mapping_value":
+                    expected = float(solution[source][source_key])
+                else:
+                    raise ValueError("unknown derived-field operation")
+            except (KeyError, TypeError, ValueError, OverflowError):
+                violations.append(
+                    f"cannot derive {target} from decision witness field {source}"
+                )
+                continue
+            if (
+                reported != reported
+                or expected != expected
+                or reported in (float("inf"), float("-inf"))
+                or expected in (float("inf"), float("-inf"))
+                or abs(reported - expected) > 1e-6
+            ):
+                violations.append(
+                    f"{target}={reported} does not match the decision-derived "
+                    f"value {expected}"
+                )
+
+        if "objective_value" in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS:
+            objective = solution.get("objective_value")
+            if (
+                isinstance(objective, bool)
+                or not isinstance(objective, (int, float))
+                or objective != objective
+                or objective in (float("inf"), float("-inf"))
+            ):
+                violations.append("objective_value must be a finite JSON number")
+
+    if not violations:
+        return None
+    return {
+        "feasible": False,
+        "violated_constraints": ["solution_schema"],
+        "violations": violations,
+        "violation_magnitudes": [],
+    }
+
+
+def _frontieror_write_unexpected_rejection(error):
+    """Turn malformed candidate/checker exceptions into a normal rejection."""
+    import json as _frontieror_json
+    import sys as _frontieror_sys
+
+    result_path = None
+    for index, argument in enumerate(_frontieror_sys.argv):
+        if argument == "--result_path" and index + 1 < len(_frontieror_sys.argv):
+            result_path = _frontieror_sys.argv[index + 1]
+            break
+        if argument.startswith("--result_path="):
+            result_path = argument.split("=", 1)[1]
+            break
+    if not result_path:
+        return False
+    try:
+        with open(result_path, "w") as result_handle:
+            _frontieror_json.dump(
+                {
+                    "feasible": False,
+                    "violated_constraints": ["malformed_solution"],
+                    "violations": [
+                        "checker rejected malformed candidate: "
+                        + type(error).__name__
+                        + ": "
+                        + str(error)[:500]
+                    ],
+                    "violation_magnitudes": [],
+                },
+                result_handle,
+                indent=2,
+            )
+    except Exception:
+        return False
+    return True
+
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Check feasibility of a UC candidate solution."
+    )
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to the JSON instance file.")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path to the JSON solution file.")
+    parser.add_argument("--result_path", type=str, required=True,
+                        help="Path to write the JSON feasibility result.")
+    return parser.parse_args()
+
+
+def compute_startup_windows(startup_costs):
+    """
+    Compute [lo, hi] downtime windows for each startup cost tier.
+
+    Mirrors gurobi_code.compute_startup_windows exactly: consecutive tiers
+    partition the downtime axis, lo_k = prev_hi + 1, hi_k = max_downtime_hours
+    of tier k. The last (cold) tier has hi=None (no upper bound).
+    """
+    windows = []
+    prev_max = 0
+    for tier in startup_costs:
+        lo = prev_max + 1
+        hi = tier["max_downtime_hours"]  # None for the last (cold) tier
+        windows.append((lo, hi))
+        if hi is not None:
+            prev_max = hi
+    return windows
+
+
+def recompute_objective(data, sol):
+    """
+    Recompute the UC objective exactly from the reported schedule (u, p).
+
+    Objective (gurobi_code.py): for every generator g and period t,
+        NL_g * u[g,t]                              (no-load cost)
+      + sum_l marginal_cost_l * pl[g,t,l]          (piecewise production cost)
+      + sum_k SC_k * delta[g,t,k]                  (downtime-dependent startup)
+
+    pl and delta are cost-minimised LP auxiliaries with no binding
+    constraint other than their definitions, so they are determined by
+    (u, p):
+      * production cost = cheapest segment fill of p-p_min*u; segments are
+        contiguous and monotone in marginal cost, so the greedy positional
+        fill is optimal.
+      * startup cost = cheapest eligible tier for each startup event,
+        where tier k (< cold) is eligible iff a shutdown lies in its
+        downtime window [lo_k, hi_k] (in-horizon w events or, for an
+        initially-off generator, the pre-horizon shutdown). The cold tier
+        is always eligible. This replicates the matching-formulation delta
+        constraints in gurobi_code.py.
+
+    Returns the recomputed objective (float).
+    """
+    generators = data["generators"]
+    demand = data["demand"]
+    T = len(demand)
+    schedule = sol["schedule"]
+
+    total = 0.0
+    for gd in generators:
+        g_id = gd["id"]
+        s = schedule[g_id]
+        u_arr = s["u"]
+        p_arr = s["p"]
+
+        p_min = gd["p_min"]
+        NL = gd["no_load_cost"]
+        segs = gd["production_cost_segments"]
+        tiers = gd["startup_costs"]
+        windows = compute_startup_windows(tiers)
+        n_tiers = len(tiers)
+        init = int(gd["initial_status"])
+
+        # Derive v, w from u exactly as constraints 3/4/8/9 do above.
+        u0 = 1 if init > 0 else 0
+        u_prev_arr = [u0] + list(u_arr[:-1])
+        v_arr = [max(0, u_arr[t] - u_prev_arr[t]) for t in range(T)]
+        w_arr = [max(0, u_prev_arr[t] - u_arr[t]) for t in range(T)]
+
+        for t in range(T):
+            ut = u_arr[t]
+
+            # --- No-load cost --------------------------------------------
+            total += NL * ut
+
+            # --- Piecewise production cost (greedy / cheapest fill) ------
+            # When the generator is off, pl is pinned to 0 in the MIP, so
+            # there is no production cost regardless of p.
+            if ut >= 0.5:
+                remaining = p_arr[t] - p_min * ut
+                for seg in segs:
+                    width = seg["output_mw_end"] - seg["output_mw_start"]
+                    take = min(max(remaining, 0.0), width)
+                    total += take * seg["marginal_cost_per_mwh"]
+                    remaining -= take
+
+            # --- Downtime-dependent startup cost -------------------------
+            if v_arr[t] >= 0.5:
+                best_cost = None
+                for k in range(n_tiers):
+                    if k == n_tiers - 1:
+                        eligible = True  # cold tier: residual, no window UB
+                    else:
+                        lo, hi = windows[k]
+                        eligible = False
+                        for i in range(lo, hi + 1):
+                            prev_t = t - i
+                            if prev_t >= 0:
+                                if w_arr[prev_t] >= 0.5:
+                                    eligible = True
+                                    break
+                            elif init < 0:
+                                # pre-horizon shutdown |init| periods before t=0
+                                shutdown_ago = t + abs(init)
+                                if lo <= shutdown_ago <= hi:
+                                    eligible = True
+                                    break
+                    if eligible:
+                        c = tiers[k]["cost"]
+                        if best_cost is None or c < best_cost:
+                            best_cost = c
+                if best_cost is not None:
+                    total += best_cost
+
+    return total
+
+
+def main():
+    args = parse_args()
+
+    with open(args.instance_path) as f:
+        data = json.load(f)
+    with open(args.solution_path) as f:
+        sol = json.load(f)
+        _frontieror_contract_result = _frontieror_validate_solution_contract(sol)
+        if _frontieror_contract_result is not None:
+            with open(args.result_path, "w") as _frontieror_result_handle:
+                json.dump(
+                    _frontieror_contract_result,
+                    _frontieror_result_handle,
+                    indent=2,
+                )
+            return
+
+    tol = 1e-5
+    eps = 1e-5
+
+    generators = data["generators"]
+    demand = data["demand"]
+    reserve = data.get("reserve_requirement", [0.0] * len(demand))
+    T = len(demand)
+    G = len(generators)
+    schedule = sol["schedule"]
+    gen_ids = [gd["id"] for gd in generators]
+
+    violated_set = set()
+    violation_messages = []  # (constraint_idx, message)
+    violation_magnitudes = []
+
+    def record(constraint_idx, msg, lhs, rhs, operator):
+        """Check a constraint and record violation if any."""
+        if operator == "<=":
+            violation_amount = lhs - rhs
+        elif operator == ">=":
+            violation_amount = rhs - lhs
+        elif operator == "=":
+            violation_amount = abs(lhs - rhs)
+        else:
+            return
+
+        if violation_amount > tol:
+            violated_set.add(constraint_idx)
+            violation_messages.append((constraint_idx, msg))
+            normalizer = max(abs(rhs), eps)
+            violation_magnitudes.append({
+                "constraint": constraint_idx,
+                "lhs": float(lhs),
+                "rhs": float(rhs),
+                "raw_excess": float(violation_amount),
+                "normalizer": float(normalizer),
+                "ratio": float(violation_amount / normalizer),
+            })
+
+    # Initial condition helpers
+    def u0(g_idx):
+        return 1 if generators[g_idx]["initial_status"] > 0 else 0
+
+    def p0(g_idx):
+        gd = generators[g_idx]
+        return gd["initial_power"] if gd["initial_status"] > 0 else 0.0
+
+    # ==========================================================================
+    # Constraint 1: Power balance  sum_g p[g,t] = demand[t]
+    # ==========================================================================
+    for t in range(T):
+        total_p = sum(schedule[gen_ids[g]]["p"][t] for g in range(G))
+        record(1,
+               f"Power balance violated at t={t+1}: sum_p={total_p:.4f}, demand={demand[t]:.4f}",
+               total_p, demand[t], "=")
+
+    # ==========================================================================
+    # Per-generator constraints (2-10, 11, 16-18)
+    # ==========================================================================
+    for g_idx in range(G):
+        gd = generators[g_idx]
+        g_id = gd["id"]
+        s = schedule[g_id]
+        u_arr = s["u"]
+        p_arr = s["p"]
+        pb_arr = s["pb"]
+
+        # Derive v, w from u (1-bin projection): v(t)=1 iff u(t)=1 and u(t-1)=0
+        # (startup event), w(t)=1 iff u(t-1)=1 and u(t)=0 (shutdown event).
+        # If the solver chose to export v, w explicitly, we still use the
+        # derived values since only u is in the original formulation.
+        u_prev_arr = [1 if generators[g_idx]["initial_status"] > 0 else 0] + list(u_arr[:-1])
+        v_arr = [max(0, u_arr[t] - u_prev_arr[t]) for t in range(T)]
+        w_arr = [max(0, u_prev_arr[t] - u_arr[t]) for t in range(T)]
+
+        p_min = gd["p_min"]
+        p_max = gd["p_max"]
+        RU = gd["ramp_up_limit"]
+        RD = gd["ramp_down_limit"]
+        SU = gd["startup_ramp_limit"]
+        SD = gd["shutdown_ramp_limit"]
+        UT = int(gd["min_up_time"])
+        DT = int(gd["min_down_time"])
+        init = int(gd["initial_status"])
+
+        # Compute TRU, TRD for VUB
+        TRU = max(0, math.ceil((p_max - SU) / RU)) if RU > 0 else 0
+        TRD_val = max(0, math.ceil((p_max - SD) / RD)) if RD > 0 else 0
+        apply_vub = (UT >= TRU + TRD_val + 2)
+
+        for t in range(T):
+            ut = u_arr[t]
+            vt = v_arr[t]
+            wt = w_arr[t]
+            pt = p_arr[t]
+            pbt = pb_arr[t]
+            u_prev = u_arr[t - 1] if t > 0 else u0(g_idx)
+            p_prev = p_arr[t - 1] if t > 0 else p0(g_idx)
+
+            # ------------------------------------------------------------------
+            # Constraint 2 INTENTIONALLY SKIPPED: the 3-bin definitional
+            # identity u(t)-u(t-1) = v(t)-w(t) is not an original 1-bin
+            # constraint. With v, w derived from u above, it is trivially
+            # satisfied by construction.
+            # ------------------------------------------------------------------
+            # Constraint 3: Minimum up-time
+            # sum_{s=max(1,t-UT+1)}^{t} v[g,s] <= u[g,t]
+            # ------------------------------------------------------------------
+            start_ut = max(0, t - UT + 1)
+            sum_v = sum(v_arr[ss] for ss in range(start_ut, t + 1))
+            record(3,
+                   f"Min up-time violated for {g_id} at t={t+1}: sum_v={sum_v:.4f}, u={ut:.4f}",
+                   sum_v, ut, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 4: Minimum down-time
+            # sum_{s=max(1,t-DT+1)}^{t} w[g,s] <= 1 - u[g,t]
+            # ------------------------------------------------------------------
+            start_dt = max(0, t - DT + 1)
+            sum_w = sum(w_arr[ss] for ss in range(start_dt, t + 1))
+            record(4,
+                   f"Min down-time violated for {g_id} at t={t+1}: sum_w={sum_w:.4f}, 1-u={1-ut:.4f}",
+                   sum_w, 1 - ut, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 5: Generation lower bound  p[g,t] >= p_min * u[g,t]
+            # ------------------------------------------------------------------
+            record(5,
+                   f"Gen lower limit violated for {g_id} at t={t+1}: "
+                   f"p={pt:.4f} < p_min*u={p_min * ut:.4f}",
+                   p_min * ut, pt, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 6: Generation upper bound  pb[g,t] <= p_max * u[g,t]
+            # ------------------------------------------------------------------
+            record(6,
+                   f"Gen upper limit violated for {g_id} at t={t+1}: "
+                   f"pb={pbt:.4f} > p_max*u={p_max * ut:.4f}",
+                   pbt, p_max * ut, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 7: Power <= available  p[g,t] <= pb[g,t]
+            # ------------------------------------------------------------------
+            record(7,
+                   f"p > pb for {g_id} at t={t+1}: p={pt:.4f}, pb={pbt:.4f}",
+                   pt, pbt, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 8: Ramp-up
+            # p[g,t] - p[g,t-1] <= RU * u[g,t-1] + SU * v[g,t]
+            # ------------------------------------------------------------------
+            ramp_up_lhs = pt - p_prev
+            ramp_up_rhs = RU * u_prev + SU * vt
+            record(8,
+                   f"Ramp-up violated for {g_id} at t={t+1}: "
+                   f"delta_p={ramp_up_lhs:.4f}, limit={ramp_up_rhs:.4f}",
+                   ramp_up_lhs, ramp_up_rhs, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 9: Ramp-down
+            # p[g,t-1] - p[g,t] <= RD * u[g,t] + SD * w[g,t]
+            # ------------------------------------------------------------------
+            ramp_dn_lhs = p_prev - pt
+            ramp_dn_rhs = RD * ut + SD * wt
+            record(9,
+                   f"Ramp-down violated for {g_id} at t={t+1}: "
+                   f"delta_p={ramp_dn_lhs:.4f}, limit={ramp_dn_rhs:.4f}",
+                   ramp_dn_lhs, ramp_dn_rhs, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 10: VUB inequality (Slide 10)
+            # p(t) <= p_max*u(t) - sum_i coeff_i*v(t-i) - sum_i coeff_i*w(t+1+i)
+            # Only when UT >= TRU + TRD + 2
+            # ------------------------------------------------------------------
+            if apply_vub:
+                startup_sum = 0.0
+                for i in range(TRU + 1):
+                    coeff = max(0.0, p_max - (SU + i * RU))
+                    ti = t - i
+                    if 0 <= ti < T:
+                        startup_sum += coeff * v_arr[ti]
+
+                shutdown_sum = 0.0
+                for i in range(TRD_val + 1):
+                    coeff = max(0.0, p_max - (SD + i * RD))
+                    ti = t + 1 + i
+                    if 0 <= ti < T:
+                        shutdown_sum += coeff * w_arr[ti]
+
+                vub_rhs = p_max * ut - startup_sum - shutdown_sum
+                record(10,
+                       f"VUB violated for {g_id} at t={t+1}: "
+                       f"p={pt:.4f}, VUB_limit={vub_rhs:.4f}",
+                       pt, vub_rhs, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 11: Piecewise sum feasibility (implied)
+            # p_above_min = p[g,t] - p_min*u[g,t] must be in [0, (p_max-p_min)*u[g,t]]
+            # Lower part (>= 0) is constraint 5; upper part checked here.
+            # ------------------------------------------------------------------
+            p_above_min = pt - p_min * ut
+            max_above_min = (p_max - p_min) * ut
+            record(11,
+                   f"Piecewise sum feasibility violated for {g_id} at t={t+1}: "
+                   f"p_above_min={p_above_min:.4f}, max={max_above_min:.4f}",
+                   p_above_min, max_above_min, "<=")
+
+            # ------------------------------------------------------------------
+            # Constraint 16: Binary constraint u in {0, 1} (original variable).
+            # v, w are derived from u, so their domain is automatic.
+            # ------------------------------------------------------------------
+            rounded = round(ut)
+            if rounded not in (0, 1):
+                dev = min(abs(ut), abs(ut - 1))
+                record(16,
+                       f"Binary violated for {g_id}.u at t={t+1}: val={ut:.6f}",
+                       dev, 0.0, "=")
+            else:
+                dev = abs(ut - rounded)
+                record(16,
+                       f"Binary violated for {g_id}.u at t={t+1}: val={ut:.6f}",
+                       dev, 0.0, "=")
+
+            # ------------------------------------------------------------------
+            # Constraint 17: Non-negativity  p >= 0, pb >= 0
+            # ------------------------------------------------------------------
+            record(17,
+                   f"Negative p for {g_id} at t={t+1}: p={pt:.6f}",
+                   0.0, pt, "<=")
+            record(17,
+                   f"Negative pb for {g_id} at t={t+1}: pb={pbt:.6f}",
+                   0.0, pbt, "<=")
+
+        # ----------------------------------------------------------------------
+        # Constraint 18: Initial up/down time obligations
+        # If init > 0: u[g,t] must be 1 for t=1..max(0, UT-init)
+        # If init < 0: u[g,t] must be 0 for t=1..max(0, DT-|init|)
+        # ----------------------------------------------------------------------
+        if init > 0:
+            must_on = max(0, UT - init)
+            for t in range(min(must_on, T)):
+                if u_arr[t] < 1 - tol:
+                    record(18,
+                           f"Initial up-time obligation violated for {g_id} at t={t+1}: "
+                           f"u={u_arr[t]:.4f}, must be 1",
+                           1.0, u_arr[t], "<=")
+        elif init < 0:
+            must_off = max(0, DT - abs(init))
+            for t in range(min(must_off, T)):
+                if u_arr[t] > tol:
+                    record(18,
+                           f"Initial down-time obligation violated for {g_id} at t={t+1}: "
+                           f"u={u_arr[t]:.4f}, must be 0",
+                           u_arr[t], 0.0, "<=")
+
+    # ==========================================================================
+    # Constraint 15: Reserve requirement  sum_g pb[g,t] >= demand[t] + reserve[t]
+    # ==========================================================================
+    for t in range(T):
+        total_pb = sum(schedule[gen_ids[g]]["pb"][t] for g in range(G))
+        rhs_val = demand[t] + reserve[t]
+        record(15,
+               f"Reserve violated at t={t+1}: sum_pb={total_pb:.4f}, "
+               f"demand+reserve={rhs_val:.4f}",
+               rhs_val, total_pb, "<=")
+
+    # ==========================================================================
+    # Constraint 19: Objective consistency (Tier C anti-score-gaming check)
+    #
+    # Recompute the objective exactly from (u, p) and reject when the
+    # self-reported objective_value disagrees. The recompute is exact
+    # because the cost-only auxiliaries pl (piecewise segments) and delta
+    # (startup tiers) are fully determined by (u, p) under minimisation
+    # (see recompute_objective docstring). Tolerance: 1e-6 relative with a
+    # 1e-3 absolute floor -- loose enough to absorb float summation noise
+    # (observed |rel diff| <= 1e-13 on Gurobi references), tight enough to
+    # catch any fabricated objective_value.
+    # ==========================================================================
+    reported_raw = sol.get("objective_value")
+    reported = None
+    if reported_raw is not None:
+        try:
+            reported = float(reported_raw)
+        except (TypeError, ValueError):
+            reported = None
+
+    if reported is not None:
+        true_obj = recompute_objective(data, sol)
+        # Map a non-finite reported objective onto an effective value that
+        # always trips the tolerance test (still a fabricated objective).
+        if math.isnan(reported):
+            eff = true_obj + max(1.0, abs(true_obj))
+        elif math.isinf(reported):
+            eff = math.copysign(sys.float_info.max, reported)
+        else:
+            eff = reported
+        abs_diff = abs(eff - true_obj)
+        obj_tol = max(1e-3, 1e-6 * abs(true_obj))
+        if abs_diff > obj_tol:
+            violated_set.add(19)
+            msg = (f"Objective consistency violated: reported objective_value="
+                   f"{reported} differs from recomputed cost "
+                   f"(no-load + piecewise production + startup) ="
+                   f"{true_obj:.6f} (|diff|={abs_diff:.6g}, tol={obj_tol:.6g})")
+            violation_messages.append((19, msg))
+            normalizer = max(abs(true_obj), eps)
+            violation_magnitudes.append({
+                "constraint": 19,
+                "lhs": float(eff),
+                "rhs": float(true_obj),
+                "raw_excess": float(abs_diff),
+                "normalizer": float(normalizer),
+                "ratio": float(abs_diff / normalizer),
+            })
+
+    # ==========================================================================
+    # Compile results
+    # ==========================================================================
+    violated_constraints = sorted(violated_set)
+
+    # Aggregate messages: collect unique messages per constraint
+    aggregated_violations = []
+    for c_idx in violated_constraints:
+        msgs = [msg for ci, msg in violation_messages if ci == c_idx]
+        if len(msgs) <= 3:
+            aggregated_violations.extend(msgs)
+        else:
+            aggregated_violations.extend(msgs[:2])
+            aggregated_violations.append(
+                f"... and {len(msgs) - 2} more constraint {c_idx} violations"
+            )
+
+    result = {
+        "feasible": len(violated_constraints) == 0,
+        "violated_constraints": violated_constraints,
+        "violations": aggregated_violations,
+        "violation_magnitudes": violation_magnitudes,
+    }
+
+    with open(args.result_path, "w") as f:
+        json.dump(result, f, indent=2)
+
+    if result["feasible"]:
+        print("Solution is FEASIBLE.")
+    else:
+        print(f"Solution is INFEASIBLE. Violated constraints: {violated_constraints}")
+        print(f"Total violation instances: {len(violation_magnitudes)}")
+
+    print(f"Result written to: {args.result_path}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as _frontieror_unexpected_error:
+        if not _frontieror_write_unexpected_rejection(
+            _frontieror_unexpected_error
+        ):
+            raise

tasks/knueven2020/gurobi_code.py

@@ -0,0 +1,437 @@
+#!/usr/bin/env python3
+"""
+Gurobi implementation of the Unit Commitment (UC) mathematical model.
+
+Paper: Knueven, Ostrowski, Watson (2020)
+       "On Mixed Integer Programming Formulations for the Unit Commitment Problem"
+
+This program implements the standard 3-binary-variable (3-bin) UC formulation
+as the base mathematical model described in the paper. It uses:
+  - Binary variables u(g,t), v(g,t), w(g,t) for on/off, startup, shutdown
+  - Logical linking constraints
+  - Minimum up/down time constraints (Rajan and Takriti 2005 style)
+  - Generation limits
+  - Startup/shutdown ramping constraints
+  - Piecewise linear production costs (disaggregated)
+  - Downtime-dependent startup costs (matching formulation)
+  - Power balance and reserve constraints
+
+NOT SPECIFIED IN PAPER (SLIDES): The exact constraint forms for min up/down time,
+ramping, generation limits, and startup costs are not written out in the slides.
+We use the standard forms from the literature referenced in the paper (Rajan-Takriti
+2005, Carrion-Arroyo 2006 style) as inferred assumptions.
+"""
+
+import argparse
+import json
+import math
+import sys
+
+import gurobipy as gp
+from gurobipy import GRB
+import os as _os, sys as _sys
+import time
+# Walk up from this file's directory to find repo root (containing scripts/).
+_GUROBI_CODE_START_TIME = time.time()
+_repo = _os.path.dirname(_os.path.abspath(__file__))
+while _repo != _os.path.dirname(_repo) and not _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _repo = _os.path.dirname(_repo)
+if _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _sys.path.insert(0, _repo)
+try:
+    from scripts.utils.gurobi_log_helper import install_gurobi_logger
+except ImportError:
+    def install_gurobi_logger(log_path):  # no-op fallback when scripts/ unavailable
+        pass
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Solve UC problem with Gurobi (standard 3-bin formulation)."
+    )
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to the JSON instance file.")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path for the output solution JSON file.")
+    parser.add_argument("--time_limit", type=int, required=True,
+                        help="Maximum solver runtime in seconds.")
+    parser.add_argument("--log_path", type=str, default=None, help="Path to log incumbent solutions")
+    return parser.parse_args()
+
+
+def compute_startup_windows(startup_costs):
+    """
+    Compute [lo, hi] downtime windows for each startup cost tier.
+
+    The matching formulation assigns a startup to tier k if the unit was offline
+    for lo_k to hi_k periods. The last tier (cold) has hi=None (no upper bound).
+
+    Inferred assumption: consecutive tiers partition the downtime axis, where
+    lo_k = prev_hi + 1 and hi_k = max_downtime_hours for tier k.
+    """
+    windows = []
+    prev_max = 0
+    for tier in startup_costs:
+        lo = prev_max + 1
+        hi = tier["max_downtime_hours"]  # None for the last (cold) tier
+        windows.append((lo, hi))
+        if hi is not None:
+            prev_max = hi
+    return windows
+
+
+def build_and_solve(data, time_limit):
+    """
+    Build and solve the standard 3-bin UC MIP using Gurobi.
+
+    Returns the Gurobi model and key variable dictionaries.
+    """
+    generators = data["generators"]
+    demand = data["demand"]
+    reserve = data.get("reserve_requirement", [0.0] * len(demand))
+    T = len(demand)
+    G = len(generators)
+
+    # Pre-process generator parameters
+    gen = []
+    for gd in generators:
+        g = {
+            "id": gd["id"],
+            "p_max": gd["p_max"],
+            "p_min": gd["p_min"],
+            "RU": gd["ramp_up_limit"],
+            "RD": gd["ramp_down_limit"],
+            "SU": gd["startup_ramp_limit"],    # max power at first period online
+            "SD": gd["shutdown_ramp_limit"],   # max power at last period online
+            "UT": int(gd["min_up_time"]),
+            "DT": int(gd["min_down_time"]),
+            "NL": gd["no_load_cost"],
+            "init": int(gd["initial_status"]),  # >0: on for n periods, <0: off for |n| periods
+            "p0": gd["initial_power"],
+            "tiers": gd["startup_costs"],
+            "segs": gd["production_cost_segments"],
+            "windows": compute_startup_windows(gd["startup_costs"]),
+        }
+        gen.append(g)
+
+    # -------------------------------------------------------------------------
+    # Create Gurobi model
+    # -------------------------------------------------------------------------
+    model = gp.Model("UC_Standard_3bin")
+    model.setParam("Threads", 1)
+    model.setParam("TimeLimit", time_limit)
+    model.setParam("MIPGap", 1e-4)   # 0.01% optimality gap (as in paper)
+    model.setParam("OutputFlag", 1)
+
+    # -------------------------------------------------------------------------
+    # Decision Variables (indexed t=1..T)
+    # -------------------------------------------------------------------------
+    # Binary status, startup, shutdown
+    u = model.addVars(G, range(1, T + 1), vtype=GRB.BINARY, name="u")
+    v = model.addVars(G, range(1, T + 1), vtype=GRB.BINARY, name="v")
+    w = model.addVars(G, range(1, T + 1), vtype=GRB.BINARY, name="w")
+
+    # Power output and available power (for reserve)
+    p = model.addVars(G, range(1, T + 1), lb=0.0, name="p")
+    pb = model.addVars(G, range(1, T + 1), lb=0.0, name="pb")
+
+    # Piecewise segment power pl[g, t, l]
+    pl = {}
+    for g_idx in range(G):
+        n_segs = len(gen[g_idx]["segs"])
+        for t in range(1, T + 1):
+            for l in range(n_segs):
+                pl[(g_idx, t, l)] = model.addVar(lb=0.0, name=f"pl_{g_idx}_{t}_{l}")
+
+    # Startup cost tier indicators delta[g, t, k]
+    delta = {}
+    for g_idx in range(G):
+        n_tiers = len(gen[g_idx]["tiers"])
+        for t in range(1, T + 1):
+            for k in range(n_tiers):
+                delta[(g_idx, t, k)] = model.addVar(lb=0.0, ub=1.0,
+                                                      name=f"delta_{g_idx}_{t}_{k}")
+
+    model.update()
+
+    # -------------------------------------------------------------------------
+    # Enforce initial up/down time obligations
+    # -------------------------------------------------------------------------
+    # Inferred assumption: if init_status > 0 (on for n periods), the unit must
+    # remain on for max(0, UT - n) more periods; similarly for off.
+    for g_idx in range(G):
+        g = gen[g_idx]
+        init = g["init"]
+        if init > 0:
+            must_on = max(0, g["UT"] - init)
+            for t in range(1, min(must_on, T) + 1):
+                u[g_idx, t].lb = 1.0
+        elif init < 0:
+            must_off = max(0, g["DT"] - abs(init))
+            for t in range(1, min(must_off, T) + 1):
+                u[g_idx, t].ub = 0.0
+
+    model.update()
+
+    # -------------------------------------------------------------------------
+    # Helper: get initial-condition values as Python scalars for t=0
+    # -------------------------------------------------------------------------
+    def u0(g_idx):
+        return 1 if gen[g_idx]["init"] > 0 else 0
+
+    def p0(g_idx):
+        return gen[g_idx]["p0"] if gen[g_idx]["init"] > 0 else 0.0
+
+    # -------------------------------------------------------------------------
+    # Logical linking: u[g,t] - u[g,t-1] = v[g,t] - w[g,t]
+    # -------------------------------------------------------------------------
+    for g_idx in range(G):
+        for t in range(1, T + 1):
+            u_prev = u[g_idx, t - 1] if t > 1 else u0(g_idx)
+            model.addConstr(
+                u[g_idx, t] - u_prev == v[g_idx, t] - w[g_idx, t],
+                name=f"link_{g_idx}_{t}"
+            )
+
+    # -------------------------------------------------------------------------
+    # Minimum up-time constraints (Rajan-Takriti 2005 style)
+    # sum_{s=max(1,t-UT+1)}^{t} v[g,s] <= u[g,t]
+    # -------------------------------------------------------------------------
+    for g_idx in range(G):
+        UT = gen[g_idx]["UT"]
+        for t in range(1, T + 1):
+            start = max(1, t - UT + 1)
+            model.addConstr(
+                gp.quicksum(v[g_idx, s] for s in range(start, t + 1)) <= u[g_idx, t],
+                name=f"minup_{g_idx}_{t}"
+            )
+
+    # -------------------------------------------------------------------------
+    # Minimum down-time constraints (Rajan-Takriti 2005 style)
+    # sum_{s=max(1,t-DT+1)}^{t} w[g,s] <= 1 - u[g,t]
+    # -------------------------------------------------------------------------
+    for g_idx in range(G):
+        DT = gen[g_idx]["DT"]
+        for t in range(1, T + 1):
+            start = max(1, t - DT + 1)
+            model.addConstr(
+                gp.quicksum(w[g_idx, s] for s in range(start, t + 1)) <= 1 - u[g_idx, t],
+                name=f"mindn_{g_idx}_{t}"
+            )
+
+    # -------------------------------------------------------------------------
+    # Generation limits
+    # p_min * u[g,t] <= p[g,t] <= pb[g,t] <= p_max * u[g,t]
+    # -------------------------------------------------------------------------
+    for g_idx in range(G):
+        g = gen[g_idx]
+        for t in range(1, T + 1):
+            model.addConstr(p[g_idx, t] >= g["p_min"] * u[g_idx, t],
+                            name=f"pmin_{g_idx}_{t}")
+            model.addConstr(pb[g_idx, t] <= g["p_max"] * u[g_idx, t],
+                            name=f"pmax_{g_idx}_{t}")
+            model.addConstr(p[g_idx, t] <= pb[g_idx, t],
+                            name=f"p_le_pb_{g_idx}_{t}")
+
+    # -------------------------------------------------------------------------
+    # Ramping constraints with startup/shutdown ramp rates
+    # Ramp-up:   p[g,t] - p[g,t-1] <= RU * u[g,t-1] + SU * v[g,t]
+    # Ramp-down: p[g,t-1] - p[g,t] <= RD * u[g,t]   + SD * w[g,t]
+    # -------------------------------------------------------------------------
+    for g_idx in range(G):
+        g = gen[g_idx]
+        for t in range(1, T + 1):
+            p_prev = p[g_idx, t - 1] if t > 1 else p0(g_idx)
+            u_prev = u[g_idx, t - 1] if t > 1 else u0(g_idx)
+
+            model.addConstr(
+                p[g_idx, t] - p_prev <= g["RU"] * u_prev + g["SU"] * v[g_idx, t],
+                name=f"rampup_{g_idx}_{t}"
+            )
+            model.addConstr(
+                p_prev - p[g_idx, t] <= g["RD"] * u[g_idx, t] + g["SD"] * w[g_idx, t],
+                name=f"rampdn_{g_idx}_{t}"
+            )
+
+    # -------------------------------------------------------------------------
+    # Piecewise linear production cost disaggregation
+    # sum_l pl[g,t,l] = p[g,t] - p_min * u[g,t]
+    # 0 <= pl[g,t,l] <= (P^l - P^{l-1}) * u[g,t]   (standard upper bound)
+    # -------------------------------------------------------------------------
+    for g_idx in range(G):
+        g = gen[g_idx]
+        segs = g["segs"]
+        n_segs = len(segs)
+        for t in range(1, T + 1):
+            # Output above minimum = sum of segment outputs
+            model.addConstr(
+                gp.quicksum(pl[(g_idx, t, l)] for l in range(n_segs))
+                == p[g_idx, t] - g["p_min"] * u[g_idx, t],
+                name=f"pwsum_{g_idx}_{t}"
+            )
+            for l, seg in enumerate(segs):
+                seg_width = seg["output_mw_end"] - seg["output_mw_start"]
+                model.addConstr(
+                    pl[(g_idx, t, l)] <= seg_width * u[g_idx, t],
+                    name=f"pwub_{g_idx}_{t}_{l}"
+                )
+
+    # -------------------------------------------------------------------------
+    # Downtime-dependent startup costs (matching formulation)
+    #
+    # delta[g,t,k] = 1 iff generator g starts at time t with startup tier k.
+    # Partition: sum_k delta[g,t,k] = v[g,t]
+    # Window:    delta[g,t,k] <= sum_{i=lo_k}^{hi_k} w[g,t-i]  (for k < last tier)
+    #            (unit must have shut down in the window [lo_k, hi_k] periods ago)
+    #
+    # Inferred assumption: matching formulation assigns the cheapest eligible tier.
+    # The last (cold) tier is the residual and has no window upper bound.
+    # Pre-horizon shutdowns are treated as a constant contribution if they fall
+    # within a tier's window (based on initial_status).
+    # -------------------------------------------------------------------------
+    for g_idx in range(G):
+        g = gen[g_idx]
+        tiers = g["tiers"]
+        windows = g["windows"]
+        n_tiers = len(tiers)
+        init = g["init"]
+
+        for t in range(1, T + 1):
+            # Partition constraint
+            model.addConstr(
+                gp.quicksum(delta[(g_idx, t, k)] for k in range(n_tiers))
+                == v[g_idx, t],
+                name=f"tiersum_{g_idx}_{t}"
+            )
+
+            # Window upper bounds for all but the last (cold) tier
+            for k in range(n_tiers - 1):
+                lo, hi = windows[k]
+                w_terms = []
+                for i in range(lo, hi + 1):
+                    prev_t = t - i
+                    if prev_t >= 1:
+                        w_terms.append(w[g_idx, prev_t])
+                    elif prev_t <= 0 and init < 0:
+                        # Pre-horizon shutdown: unit was off for |init| periods before t=1.
+                        # At period t, that shutdown occurred (t-1) + |init| periods ago.
+                        shutdown_ago = (t - 1) + abs(init)
+                        if lo <= shutdown_ago <= hi:
+                            w_terms.append(1.0)  # constant: pre-horizon shutdown in window
+
+                if w_terms:
+                    model.addConstr(
+                        delta[(g_idx, t, k)] <= gp.quicksum(w_terms),
+                        name=f"tierwin_{g_idx}_{t}_{k}"
+                    )
+                else:
+                    # No valid shutdown in this window: tier k is infeasible at this t
+                    model.addConstr(
+                        delta[(g_idx, t, k)] == 0,
+                        name=f"tierinf_{g_idx}_{t}_{k}"
+                    )
+
+    # -------------------------------------------------------------------------
+    # Power balance (copper-plate, equality)
+    # sum_g p[g,t] = D[t]
+    # -------------------------------------------------------------------------
+    for t in range(1, T + 1):
+        model.addConstr(
+            gp.quicksum(p[g_idx, t] for g_idx in range(G)) == demand[t - 1],
+            name=f"balance_{t}"
+        )
+
+    # -------------------------------------------------------------------------
+    # Reserve requirement
+    # sum_g pb[g,t] >= D[t] + R[t]
+    # -------------------------------------------------------------------------
+    for t in range(1, T + 1):
+        model.addConstr(
+            gp.quicksum(pb[g_idx, t] for g_idx in range(G))
+            >= demand[t - 1] + reserve[t - 1],
+            name=f"reserve_{t}"
+        )
+
+    # -------------------------------------------------------------------------
+    # Objective function
+    # min sum_g sum_t [ NL_g * u[g,t]
+    #                  + sum_l f^l * pl[g,t,l]
+    #                  + sum_k SC_k * delta[g,t,k] ]
+    # -------------------------------------------------------------------------
+    obj_terms = []
+    for g_idx in range(G):
+        g = gen[g_idx]
+        for t in range(1, T + 1):
+            obj_terms.append(g["NL"] * u[g_idx, t])
+            for l, seg in enumerate(g["segs"]):
+                obj_terms.append(seg["marginal_cost_per_mwh"] * pl[(g_idx, t, l)])
+            for k, tier in enumerate(g["tiers"]):
+                obj_terms.append(tier["cost"] * delta[(g_idx, t, k)])
+
+    model.setObjective(gp.quicksum(obj_terms), GRB.MINIMIZE)
+
+    # -------------------------------------------------------------------------
+    # Solve
+    # -------------------------------------------------------------------------
+    model.optimize()
+
+    return model, u, v, w, p, pb, pl, delta, gen, G, T
+
+
+def extract_solution(model, u, v, w, p, pb, pl, delta, gen, G, T):
+    """Extract solution values from Gurobi model."""
+    status = model.Status
+
+    # Attempt to get best objective value
+    obj_val = None
+    if model.SolCount > 0:
+        obj_val = model.ObjVal
+
+    solution = {
+        "objective_value": obj_val,
+        "status": status,
+        "mip_gap": model.MIPGap if model.SolCount > 0 else None,
+        "solve_time": model.Runtime,
+        "schedule": {}
+    }
+
+    if model.SolCount > 0:
+        # Expose only the 1-bin original variables (u, p, pb); v, w are 3-bin
+        # internal auxiliaries derivable from u as v(t)=max(0,u(t)-u(t-1)),
+        # w(t)=max(0,u(t-1)-u(t)). pl and delta are piecewise/tier auxiliaries.
+        for g_idx in range(G):
+            g_id = gen[g_idx]["id"]
+            solution["schedule"][g_id] = {
+                "u": [round(u[g_idx, t].X) for t in range(1, T + 1)],
+                "p": [p[g_idx, t].X for t in range(1, T + 1)],
+                "pb": [pb[g_idx, t].X for t in range(1, T + 1)],
+            }
+
+    return solution
+
+
+def main():
+    args = parse_args()
+    install_gurobi_logger(args.log_path)
+
+    with open(args.instance_path) as f:
+        data = json.load(f)
+
+    model, u, v, w, p, pb, pl, delta, gen, G, T = build_and_solve(data, args.time_limit)
+    solution = extract_solution(model, u, v, w, p, pb, pl, delta, gen, G, T)
+
+    with open(args.solution_path, "w") as f:
+        solution["runtime"] = time.time() - _GUROBI_CODE_START_TIME
+        json.dump(solution, f, indent=2)
+
+    if solution["objective_value"] is not None:
+        print(f"Objective value: {solution['objective_value']:.4f}")
+        print(f"MIP gap: {solution['mip_gap']:.6%}")
+    else:
+        print("No feasible solution found within the time limit.")
+
+    print(f"Solution written to: {args.solution_path}")
+
+
+if __name__ == "__main__":
+    main()

tasks/knueven2020/gurobi_feasi_result/large_feasi_result_1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/knueven2020/gurobi_feasi_result/large_feasi_result_2.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/knueven2020/gurobi_feasi_result/large_feasi_result_3.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/knueven2020/gurobi_feasi_result/large_feasi_result_4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/knueven2020/gurobi_feasi_result/large_feasi_result_5.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/knueven2020/gurobi_feasi_result/tiny_feasi_result.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3269392edcbb7720882e77caadb88b4a9cf2fda04cf482cebd23baace4a531fd
+size 102

tasks/knueven2020/gurobi_solution/large_solution_1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b42a22967be08c5ec9b2267327f058e637166cfb9413b510f7ec617e1f47d7cf
+size 1795538

tasks/knueven2020/gurobi_solution/large_solution_2.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48b09f42cd47cf8d47d7b420298bfc2fa2c984526110e9afc496f2b69ecf2be0
+size 1903310

tasks/knueven2020/gurobi_solution/large_solution_3.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4a08ec1485cbe2d2bbcc96fba2acee65ac25ae99dc3ecf3897a06575da90e44
+size 1921782

tasks/knueven2020/gurobi_solution/large_solution_4.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82477095bb07ccdcf0340b9150bff46a7266a979912b6959ccc921b24bb20c55
+size 1898417

tasks/knueven2020/gurobi_solution/large_solution_5.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c98b97b4d74c11d57c93514b8b4019164274296b2d6ded159f67c62bbd197c6f
+size 1938911

tasks/knueven2020/gurobi_solution/tiny_solution.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12b67f5c217e924369335cd837997ac696a6b1d1eaea2c392206566ad437be10
+size 147319