Nest task folders under tasks/ (part 7)

tasks/eiselt2009/mathematical_formulation.md

@@ -0,0 +1,59 @@
+# Sets and Parameters
+
+- $N$: set of all nodes (origins, destinations, potential hub locations); indices $i, j \in N$.
+
+- $\mathrm{Own}$: set of candidate hub nodes for the entering airline (“us”); indices $k, \ell \in \mathrm{Own}$.
+
+- $\mathrm{Comp}$: set of hub nodes of existing (competing) airlines; $|\mathrm{Comp}| = r$.
+
+- $s$: airline index; $s = o$ denotes the entering airline, $s = 1,2,\ldots$ denote incumbent airlines.
+
+- $h_{ij}$: known non-elastic demand for air traffic from origin $i$ to destination $j$.
+
+- $p$: number of hubs to be located by the entering airline (exogenously given).
+
+- $A_{k\ell s}$: basic attractiveness of the hub pair $(k, \ell)$ operated by airline $s$.
+
+- $\beta, \lambda$: attraction-decay exponents for travel time and travel cost, respectively.
+
+- $\gamma \in [0,1]$: relative weight of travel time vs. travel cost.
+
+- $\alpha \leq 1$: discount factor for interhub fare (economies of scale).
+
+- $t_{ijk\ell s}$: total travel time for route $(i,j,k,\ell)$ by airline $s$.
+
+- $c_{ijk\ell s}$: total fare for route $(i,j,k,\ell)$ by airline $s$.
+
+# Derived Quantities
+
+Utility (attraction) of route $(i,j,k,\ell)$ by airline $s$ (Equation (1)): $$\begin{equation}
+u_{ijk\ell s} \;=\; \frac{A_{k\ell s}}{\gamma\, t_{ijk\ell s}^{\beta} \;+\; (1-\gamma)\, c_{ijk\ell s}^{\lambda}} \tag{1}
+\end{equation}$$
+
+Probability that a customer traveling from $i$ to $j$ uses route $(k,\ell)$ via the entering airline $o$ (Equation (2)): $$\begin{equation}
+p_{ijk\ell o} \;=\; \frac{u_{ijk\ell o}}{\displaystyle \sum_{m, n \in \mathrm{Own}} u_{ijmno} \;+\; \sum_{s \neq o} \sum_{m, n \in \mathrm{Comp}} u_{ijmns}} \tag{2}
+\end{equation}$$
+
+# Decision Variables
+
+$$\begin{align*}
+y_k &\in \{0,1\} && \forall\, k \in \mathrm{Own} \quad (\text{1 if hub is located at $k$ by entering airline}) \\
+w_{k\ell} &\in \{0,1\} && \forall\, k, \ell \in \mathrm{Own} \quad (\text{1 if hubs are located at \emph{both} $k$ and $\ell$})
+\end{align*}$$
+
+# Objective (nonlinear sum-of-ratios form, Equation (3))
+
+$$\begin{align}
+\mathrm{P}: \quad \max\; z
+&= \sum_{i,j} \sum_{k, \ell \in \mathrm{Own}} h_{ij} \, p_{ijk\ell o} \notag \\
+&= \sum_{i,j} h_{ij}\, \frac{\displaystyle\sum_{k, \ell \in \mathrm{Own}} w_{k\ell}\, u_{ijk\ell o}}{\displaystyle\sum_{m, n \in \mathrm{Own}} w_{mn}\, u_{ijmno} \;+\; \sum_{s \neq o} \sum_{m, n \in \mathrm{Comp}} u_{ijmns}} \tag{3}
+\end{align}$$
+
+# Constraints
+
+$$\begin{align}
+w_{k\ell} &\leq y_k && \forall\, k, \ell \in \mathrm{Own} \tag{4} \\
+w_{k\ell} &\leq y_\ell && \forall\, k, \ell \in \mathrm{Own} \tag{5} \\
+\sum_{k} y_k &= p \tag{6} \\
+y_k,\; w_{k\ell} &\in \{0,1\} && \forall\, k, \ell \in \mathrm{Own} \tag{7}
+\end{align}$$

tasks/eiselt2009/problem_description.txt

@@ -0,0 +1,11 @@
+# Problem Description
+
+A region is served by an air transportation network in which several nodes represent cities that are simultaneously origins, destinations, and candidate hub locations. One or more incumbent airlines already operate hub-and-spoke networks in this region, each with a fixed set of hub airports. A new entrant airline wishes to enter this market by opening exactly a prescribed number of hubs, chosen from the full set of nodes, so as to capture as large a share of total passenger traffic as possible.
+
+The input data consists of the following. There is a set of nodes, each with spatial coordinates and a fixed waiting time representing the dwell or layover delay passengers experience at that airport. A demand matrix gives the known, non-elastic number of passengers wishing to travel from every origin to every destination. A distance matrix gives the pairwise distances between all nodes. A set of nodes is designated as the fixed hub locations of the competing airlines, and the number of hubs the entrant must open is given. Several global parameters govern customer behavior: an interhub fare discount factor that reduces the fare charged on the hub-to-hub leg of a trip to reflect economies of scale; a time-versus-cost weight that ranges from zero to one and controls how much customers value travel time relative to fare; an attraction decay exponent for travel time; an attraction decay exponent for fare; and a cost scalar that converts distances into fares. In addition, each combination of hub pair and airline has a given attractiveness value that reflects the quality of the airline, the convenience of the hub airports, and whether the route passes through a single hub or two distinct hubs.
+
+Every trip from an origin to a destination may be routed through a pair of hubs, where the two hubs may be the same node (a single-hub route) or different nodes (a two-hub route). For each airline and each ordered hub pair, the total travel time on a route equals the sum of the travel time from the origin to the first hub, the travel time between the two hubs, the travel time from the second hub to the destination, and the fixed waiting times at the origin airport, the first hub, and the second hub. Travel times on each leg are proportional to the distance between the endpoints. The total fare on a route equals the fare from the origin to the first hub, plus the interhub fare discount factor times the fare between the two hubs, plus the fare from the second hub to the destination, where each leg fare is proportional to the distance of that leg scaled by the cost scalar. For each airline, each ordered origin-destination pair (with the origin i and destination j held fixed), and each unordered pair of two distinct hubs {k, l}, only one of the two corresponding two-hub routes is considered open: namely, whichever of the route i -> k -> l -> j and the route i -> l -> k -> j yields the higher customer utility. The origin and destination are never swapped; only the visiting order of the two intermediate hubs is reversed (so the comparison is between two four-node paths that share the same first node i and the same last node j and differ only in the relative order of the two hub nodes in between).
+
+The utility that customers perceive for a particular route operated by a particular airline is the attractiveness of that hub pair divided by the sum of two terms: the time-versus-cost weight times the total travel time raised to the time decay exponent, plus the quantity (one minus the time-versus-cost weight) multiplied by (the total fare raised to the fare decay exponent). In particular, the exponentiation by the fare decay exponent applies only to the total fare and not to the product of the weight complement and the fare, and the "one minus" applies only to the time-versus-cost weight and not to the entire product; equivalently, denoting the time-versus-cost weight by gamma, the total time by t, the total fare by c, the time decay exponent by beta, and the fare decay exponent by lambda, the denominator equals gamma * t^beta + (1 - gamma) * c^lambda. The probability that a passenger traveling from a given origin to a given destination chooses a particular route offered by the entrant airline equals the utility of that route divided by the sum of the utilities of all routes offered by all airlines, including all routes the entrant offers through its opened hub pairs and all routes every incumbent airline offers through its fixed hub pairs. The expected number of passengers captured by the entrant on a given route is the demand for that origin-destination pair multiplied by this probability.
+
+The entrant must select exactly the prescribed number of nodes at which to open hubs. A hub pair is considered active for the entrant only if both nodes in the pair have been selected as hubs. The goal is to maximize the total expected number of passengers captured by the entrant across all origin-destination pairs and all of the entrant's active hub-pair routes, where capture on each origin-destination pair is the demand times the fraction of total utility contributed by the entrant's active routes.

tasks/eiselt2009/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/eiselt2009/solution_schema.json

@@ -0,0 +1,4 @@
+{
+  "objective_value": "<float> Total captured passenger demand across all origin-destination pairs for the entering airline.",
+  "hub_locations": "<list[int], length p> Node indices selected as hub locations for the entering airline."
+}

tasks/elci2022/feasibility_check.py

@@ -0,0 +1,666 @@
+#!/usr/bin/env python3
+"""
+Feasibility checker for the Stochastic Planning & Scheduling problem
+(Elci & Hooker, 2020) - Minimum Makespan variant.
+
+Checks constraints from the deterministic equivalent MILP (Eq. 22),
+numbered 1-9 from top to bottom:
+
+  Constraint 1 (22b): sum_i x_{ij} = 1           for all j in J
+  Constraint 2 (22c): beta_omega >= beta_{i,omega} for all i in I, omega in Omega
+  Constraint 3 (22d): x_{ij} in {0,1}             for all i in I, j in J
+  Constraint 4 (22e): beta_omega >= sum_t (t + p^omega_ij) z^omega_ijt
+                                                    for all i in I, j in J, omega in Omega
+  Constraint 5 (22f): z^omega_ijt <= x_{ij}       for all i,j,t,omega
+  Constraint 6 (22g): sum_i sum_t z^omega_ijt = 1  for all j in J, omega in Omega
+  Constraint 7 (22h): sum_j sum_{t' in T^omega_tij} c_{ij} z^omega_ijt' <= K_i
+                                                    for all i in I, t in T, omega in Omega
+  Constraint 8 (22i): z^omega_ijt = 0 for t < r_j  for all i,omega,j,t
+  Constraint 9 (22j): z^omega_ijt in {0,1}         for all i,j,t,omega
+
+Constraint 10 (objective consistency, Tier-C defense): the reported
+  objective_value must equal the recomputed expected makespan
+  sum_omega pi_omega * beta_omega, where beta_omega = max_j finish_j in
+  scenario omega. Every variable needed for this recompute (the per-
+  scenario finish times) is present in the solution's `schedule`, so a
+  FULL two-sided recompute is possible.
+
+  The original Constraint 4 (22e) objective check is ONE-SIDED -- it only
+  flags reported < computed. Constraint 10 adds the symmetric direction
+  (reported > computed), rejecting fabricated/inflated objective values
+  that the structural constraint checks alone would otherwise accept.
+"""
+
+import argparse
+import json
+
+# FRONTIEROR_RELEASE_CONTRACT_V2
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('assignment', 'objective_value', 'schedule')
+_FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ('schedule',)
+_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 check_feasibility(instance_path, solution_path, result_path):
+    tol = 1e-5
+    eps = 1e-5
+
+    with open(instance_path) as f:
+        inst = json.load(f)
+    with open(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(result_path, "w") as _frontieror_result_handle:
+                json.dump(
+                    _frontieror_contract_result,
+                    _frontieror_result_handle,
+                    indent=2,
+                )
+            return _frontieror_contract_result
+
+    n = inst["n"]
+    m = inst["m"]
+    S = inst["num_scenarios"]
+    K = inst["facility_capacity_limits"]       # K[i]
+    c = inst["capacity_requirements"]          # c[i][j]
+    r = inst["release_times"]                  # r[j]
+    scenarios = inst["scenarios"]
+    pi_prob = [sc["probability"] for sc in scenarios]
+    p = [sc["processing_times"] for sc in scenarios]  # p[omega][i][j]
+
+    assignment = sol.get("assignment", {})
+    schedule = sol.get("schedule", None)
+    objective_value = sol.get("objective_value", None)
+
+    violations = []
+    violation_magnitudes = []
+    violated_constraints = set()
+
+    # Parse assignment: job j -> facility i
+    assign = {}
+    for j_str, i_val in assignment.items():
+        assign[int(j_str)] = int(i_val)
+
+    # Build x[i][j] matrix from assignment
+    x = [[0] * n for _ in range(m)]
+    for j_val, i_val in assign.items():
+        if 0 <= i_val < m and 0 <= j_val < n:
+            x[i_val][j_val] = 1
+
+    # ------------------------------------------------------------------
+    # Constraint 1 (22b): sum_i x_{ij} = 1 for all j in J
+    # ------------------------------------------------------------------
+    for j in range(n):
+        lhs = sum(x[i][j] for i in range(m))
+        rhs_val = 1.0
+        violation_amount = abs(lhs - rhs_val)
+        if violation_amount > tol:
+            violated_constraints.add(1)
+            violations.append(
+                f"Constraint 1 (22b): Job {j} assigned to {lhs} facilities (expected 1)"
+            )
+            normalizer = max(abs(rhs_val), eps)
+            violation_magnitudes.append({
+                "constraint": 1,
+                "lhs": float(lhs),
+                "rhs": float(rhs_val),
+                "raw_excess": float(violation_amount),
+                "normalizer": float(normalizer),
+                "ratio": float(violation_amount / normalizer),
+            })
+
+    # ------------------------------------------------------------------
+    # Constraint 3 (22d): x_{ij} in {0,1} for all i, j
+    # Check that assignment values are valid (binary, valid facility index)
+    # ------------------------------------------------------------------
+    for j in range(n):
+        if j in assign:
+            fac = assign[j]
+            if fac < 0 or fac >= m:
+                violated_constraints.add(3)
+                violation_amount = 1.0
+                violations.append(
+                    f"Constraint 3 (22d): Job {j} assigned to invalid facility {fac} "
+                    f"(valid range 0..{m-1})"
+                )
+                violation_magnitudes.append({
+                    "constraint": 3,
+                    "lhs": float(fac),
+                    "rhs": 0.0,
+                    "raw_excess": float(violation_amount),
+                    "normalizer": max(float(m - 1), eps),
+                    "ratio": float(violation_amount / max(float(m - 1), eps)),
+                })
+
+    # ------------------------------------------------------------------
+    # Constraints 2, 4-9 require schedule data (z variables)
+    # ------------------------------------------------------------------
+    if schedule is not None:
+        # Parse schedule: sched[omega][j] = {facility, start, finish}
+        sched = {}
+        for omega_str, jobs in schedule.items():
+            omega = int(omega_str)
+            sched[omega] = {}
+            for j_str, info in jobs.items():
+                j_val = int(j_str)
+                sched[omega][j_val] = {
+                    "facility": int(info["facility"]),
+                    "start": float(info["start"]),
+                    "finish": float(info["finish"]),
+                }
+
+        for omega in range(S):
+            if omega not in sched:
+                continue
+
+            # Compute per-facility makespan (beta_{i,omega}) and scenario makespan (beta_omega)
+            beta_iw = [0.0] * m
+            for j_val in range(n):
+                if j_val not in sched[omega]:
+                    continue
+                info = sched[omega][j_val]
+                fac = info["facility"]
+                beta_iw[fac] = max(beta_iw[fac], info["finish"])
+
+            beta_omega = max(beta_iw) if any(
+                j_val in sched[omega] for j_val in range(n)
+            ) else 0.0
+
+            # ----------------------------------------------------------
+            # Constraint 2 (22c): beta_omega >= beta_{i,omega}
+            # This is a >= constraint: LHS = beta_omega, RHS = beta_{i,omega}
+            # Violated if beta_{i,omega} > beta_omega
+            # ----------------------------------------------------------
+            for i in range(m):
+                violation_amount = max(0.0, beta_iw[i] - beta_omega)
+                if violation_amount > tol:
+                    violated_constraints.add(2)
+                    violations.append(
+                        f"Constraint 2 (22c): Scenario {omega}, facility {i}: "
+                        f"beta_omega={beta_omega:.4f} < beta_{{i,omega}}={beta_iw[i]:.4f}"
+                    )
+                    normalizer = max(abs(beta_iw[i]), eps)
+                    violation_magnitudes.append({
+                        "constraint": 2,
+                        "lhs": float(beta_omega),
+                        "rhs": float(beta_iw[i]),
+                        "raw_excess": float(violation_amount),
+                        "normalizer": float(normalizer),
+                        "ratio": float(violation_amount / normalizer),
+                    })
+
+            # ----------------------------------------------------------
+            # Constraint 4 (22e): beta_omega >= finish_j for all i, j
+            # For the assigned facility, finish_j = start_j + p[omega][fac][j].
+            # Also verify finish time consistency with processing times.
+            # ----------------------------------------------------------
+            for j_val in range(n):
+                if j_val not in sched[omega]:
+                    continue
+                info = sched[omega][j_val]
+                fac = info["facility"]
+                start_j = info["start"]
+                finish_j = info["finish"]
+
+                # Verify finish = start + processing time
+                if 0 <= fac < m:
+                    expected_finish = start_j + p[omega][fac][j_val]
+                    diff = abs(finish_j - expected_finish)
+                    if diff > tol:
+                        violated_constraints.add(4)
+                        violations.append(
+                            f"Constraint 4 (22e): Scenario {omega}, job {j_val}: "
+                            f"finish={finish_j} != start({start_j}) + "
+                            f"p[{omega}][{fac}][{j_val}]({p[omega][fac][j_val]}) = {expected_finish}"
+                        )
+                        normalizer = max(abs(expected_finish), eps)
+                        violation_magnitudes.append({
+                            "constraint": 4,
+                            "lhs": float(finish_j),
+                            "rhs": float(expected_finish),
+                            "raw_excess": float(diff),
+                            "normalizer": float(normalizer),
+                            "ratio": float(diff / normalizer),
+                        })
+
+                # beta_omega >= finish_j
+                violation_amount = max(0.0, finish_j - beta_omega)
+                if violation_amount > tol:
+                    violated_constraints.add(4)
+                    violations.append(
+                        f"Constraint 4 (22e): Scenario {omega}, job {j_val}: "
+                        f"beta_omega={beta_omega:.4f} < finish={finish_j}"
+                    )
+                    normalizer = max(abs(finish_j), eps)
+                    violation_magnitudes.append({
+                        "constraint": 4,
+                        "lhs": float(beta_omega),
+                        "rhs": float(finish_j),
+                        "raw_excess": float(violation_amount),
+                        "normalizer": float(normalizer),
+                        "ratio": float(violation_amount / normalizer),
+                    })
+
+            # Check objective consistency: objective_value should equal
+            # sum pi_omega * beta_omega (computed from schedule)
+            # This is an additional check for constraint 4 validity.
+            if objective_value is not None and S > 0:
+                computed_obj = 0.0
+                all_scenarios_present = True
+                for om in range(S):
+                    if om in sched and sched[om]:
+                        mk = max(sched[om][jj]["finish"] for jj in sched[om])
+                        computed_obj += pi_prob[om] * mk
+                    else:
+                        all_scenarios_present = False
+
+                if all_scenarios_present:
+                    violation_amount = max(0.0, computed_obj - objective_value)
+                    if violation_amount > tol:
+                        violated_constraints.add(4)
+                        violations.append(
+                            f"Constraint 4 (22e): Reported objective {objective_value} "
+                            f"< computed makespan objective {computed_obj:.4f}"
+                        )
+                        normalizer = max(abs(computed_obj), eps)
+                        violation_magnitudes.append({
+                            "constraint": 4,
+                            "lhs": float(objective_value),
+                            "rhs": float(computed_obj),
+                            "raw_excess": float(violation_amount),
+                            "normalizer": float(normalizer),
+                            "ratio": float(violation_amount / normalizer),
+                        })
+
+            # ----------------------------------------------------------
+            # Constraint 5 (22f): z^omega_ijt <= x_{ij}
+            # Job scheduled on a facility must be assigned there.
+            # ----------------------------------------------------------
+            for j_val in range(n):
+                if j_val not in sched[omega]:
+                    continue
+                sched_fac = sched[omega][j_val]["facility"]
+                assigned_fac = assign.get(j_val, -1)
+                if sched_fac != assigned_fac:
+                    violated_constraints.add(5)
+                    violations.append(
+                        f"Constraint 5 (22f): Scenario {omega}, job {j_val}: "
+                        f"scheduled on facility {sched_fac} but assigned to facility {assigned_fac}"
+                    )
+                    rhs_val = 0.0  # x_{sched_fac, j} = 0
+                    violation_magnitudes.append({
+                        "constraint": 5,
+                        "lhs": 1.0,
+                        "rhs": float(rhs_val),
+                        "raw_excess": 1.0,
+                        "normalizer": max(abs(rhs_val), eps),
+                        "ratio": float(1.0 / max(abs(rhs_val), eps)),
+                    })
+
+            # ----------------------------------------------------------
+            # Constraint 6 (22g): sum_i sum_t z^omega_ijt = 1 for all j, omega
+            # Each job must be scheduled exactly once per scenario.
+            # ----------------------------------------------------------
+            for j_val in range(n):
+                count = 1 if j_val in sched[omega] else 0
+                rhs_val = 1.0
+                violation_amount = abs(count - rhs_val)
+                if violation_amount > tol:
+                    violated_constraints.add(6)
+                    violations.append(
+                        f"Constraint 6 (22g): Scenario {omega}, job {j_val}: "
+                        f"scheduled {count} times (expected 1)"
+                    )
+                    normalizer = max(abs(rhs_val), eps)
+                    violation_magnitudes.append({
+                        "constraint": 6,
+                        "lhs": float(count),
+                        "rhs": float(rhs_val),
+                        "raw_excess": float(violation_amount),
+                        "normalizer": float(normalizer),
+                        "ratio": float(violation_amount / normalizer),
+                    })
+
+            # ----------------------------------------------------------
+            # Constraint 7 (22h): Cumulative resource capacity
+            # At each time t, for facility i:
+            #   sum of c_{ij} for jobs j active at t <= K_i
+            # Job j active at t if start_j <= t < start_j + p[omega][i][j]
+            # ----------------------------------------------------------
+            facility_jobs = {i: [] for i in range(m)}
+            for j_val in range(n):
+                if j_val in sched[omega]:
+                    fac = sched[omega][j_val]["facility"]
+                    facility_jobs[fac].append(j_val)
+
+            for i in range(m):
+                if not facility_jobs[i]:
+                    continue
+
+                # Collect event times (start and finish of each job on this facility)
+                events = set()
+                for j_val in facility_jobs[i]:
+                    info = sched[omega][j_val]
+                    events.add(int(info["start"]))
+                    events.add(int(info["finish"]))
+
+                # Check resource usage at each event time and just before each event
+                times_to_check = set()
+                for ev in events:
+                    times_to_check.add(ev)
+                    if ev > 0:
+                        times_to_check.add(ev - 1)
+
+                worst_violation = 0.0
+                worst_t = None
+                worst_lhs = 0.0
+
+                for t in sorted(times_to_check):
+                    resource_used = 0.0
+                    for j_val in facility_jobs[i]:
+                        info = sched[omega][j_val]
+                        s_j = info["start"]
+                        f_j = info["finish"]
+                        if s_j <= t < f_j:
+                            resource_used += c[i][j_val]
+
+                    violation_amount = max(0.0, resource_used - K[i])
+                    if violation_amount > worst_violation:
+                        worst_violation = violation_amount
+                        worst_t = t
+                        worst_lhs = resource_used
+
+                if worst_violation > tol:
+                    violated_constraints.add(7)
+                    violations.append(
+                        f"Constraint 7 (22h): Scenario {omega}, facility {i}, "
+                        f"time {worst_t}: resource usage {worst_lhs} > capacity {K[i]}"
+                    )
+                    normalizer = max(abs(float(K[i])), eps)
+                    violation_magnitudes.append({
+                        "constraint": 7,
+                        "lhs": float(worst_lhs),
+                        "rhs": float(K[i]),
+                        "raw_excess": float(worst_violation),
+                        "normalizer": float(normalizer),
+                        "ratio": float(worst_violation / normalizer),
+                    })
+
+            # ----------------------------------------------------------
+            # Constraint 8 (22i): z^omega_ijt = 0 for t < r_j
+            # Equivalently: start_j >= r_j (release time)
+            # This is a >= constraint.
+            # ----------------------------------------------------------
+            for j_val in range(n):
+                if j_val not in sched[omega]:
+                    continue
+                start_j = sched[omega][j_val]["start"]
+                rhs_val = float(r[j_val])
+                violation_amount = max(0.0, rhs_val - start_j)
+                if violation_amount > tol:
+                    violated_constraints.add(8)
+                    violations.append(
+                        f"Constraint 8 (22i): Scenario {omega}, job {j_val}: "
+                        f"start={start_j} < release time={r[j_val]}"
+                    )
+                    normalizer = max(abs(rhs_val), eps)
+                    violation_magnitudes.append({
+                        "constraint": 8,
+                        "lhs": float(start_j),
+                        "rhs": float(rhs_val),
+                        "raw_excess": float(violation_amount),
+                        "normalizer": float(normalizer),
+                        "ratio": float(violation_amount / normalizer),
+                    })
+
+            # ----------------------------------------------------------
+            # NOTE: The original two-stage stochastic program (1)-(3) uses
+            # CONTINUOUS start-time variables s_j. The integer start_time
+            # check (formerly "Constraint 9 (22j): z^omega_ijt in {0,1}")
+            # only applies to the time-indexed deterministic-equivalent
+            # reformulation (22), where z^omega_ijt binary requires starts
+            # to land on integer time indices. LLM-evolved algorithms that
+            # solve the original continuous-time problem produce valid
+            # non-integer starts, which this checker must accept.
+            # Accordingly, the integer-start check is INTENTIONALLY OMITTED.
+            # ----------------------------------------------------------
+
+    # ------------------------------------------------------------------
+    # Constraint 10 (objective consistency, full two-sided recompute):
+    #   The reported objective_value must equal the expected makespan
+    #     sum_{omega} pi_omega * beta_omega,
+    #   where beta_omega = max_j finish_j in scenario omega.
+    #   All variables required for this recompute (the per-scenario job
+    #   finish times) are present in the solution's `schedule`, so a FULL
+    #   recompute is possible -- no second-stage LP needs to be re-solved.
+    #
+    #   The original Constraint 4 (22e) objective check above is
+    #   ONE-SIDED: it only flags reported < computed. This Constraint 10
+    #   check is the symmetric Tier-C defense -- it rejects ANY
+    #   disagreement (within tolerance) between the reported objective and
+    #   the recomputed one, in particular reported > computed, i.e.
+    #   fabricated / inflated objective values (e.g. sys.float_info.max)
+    #   that the structural constraint checks alone would accept.
+    # ------------------------------------------------------------------
+    if schedule is not None and objective_value is not None and S > 0:
+        obj_sched = {}
+        try:
+            for omega_str, jobs in schedule.items():
+                om = int(omega_str)
+                obj_sched[om] = {}
+                for j_str, info in jobs.items():
+                    obj_sched[om][int(j_str)] = float(info["finish"])
+        except (TypeError, ValueError, KeyError):
+            obj_sched = None
+
+        if obj_sched is not None:
+            computed_obj = 0.0
+            all_scenarios_present = True
+            for om in range(S):
+                if om in obj_sched and obj_sched[om]:
+                    computed_obj += pi_prob[om] * max(obj_sched[om].values())
+                else:
+                    all_scenarios_present = False
+
+            if all_scenarios_present:
+                try:
+                    reported = float(objective_value)
+                except (TypeError, ValueError):
+                    reported = None
+                if reported is not None:
+                    abs_diff = abs(reported - computed_obj)
+                    # 0.1% relative tolerance with a 1e-3 absolute floor
+                    obj_tol = max(1e-3, 1e-3 * abs(computed_obj))
+                    if abs_diff > obj_tol:
+                        violated_constraints.add(10)
+                        violations.append(
+                            f"Constraint 10 (objective consistency): reported "
+                            f"objective_value={reported} differs from recomputed "
+                            f"expected makespan sum_omega(pi_omega*beta_omega)="
+                            f"{computed_obj:.4f} (|diff|={abs_diff:.4g}, "
+                            f"tol={obj_tol:.4g})"
+                        )
+                        normalizer = max(abs(computed_obj), eps)
+                        violation_magnitudes.append({
+                            "constraint": 10,
+                            "lhs": float(reported),
+                            "rhs": float(computed_obj),
+                            "raw_excess": float(abs_diff),
+                            "normalizer": float(normalizer),
+                            "ratio": float(abs_diff / normalizer),
+                        })
+
+    # ------------------------------------------------------------------
+    # Build output
+    # ------------------------------------------------------------------
+    feasible = len(violated_constraints) == 0
+    result = {
+        "feasible": feasible,
+        "violated_constraints": sorted(violated_constraints),
+        "violations": violations,
+        "violation_magnitudes": violation_magnitudes,
+    }
+
+    with open(result_path, "w") as f:
+        json.dump(result, f, indent=2)
+
+    return result
+
+
+if __name__ == "__main__":
+    try:
+        parser = argparse.ArgumentParser(
+            description="Feasibility checker for stochastic planning & scheduling "
+                        "(Elci & Hooker 2020, Eq. 22)."
+        )
+        parser.add_argument(
+            "--instance_path", required=True,
+            help="Path to the JSON instance file."
+        )
+        parser.add_argument(
+            "--solution_path", required=True,
+            help="Path to the JSON solution file."
+        )
+        parser.add_argument(
+            "--result_path", required=True,
+            help="Path to write the JSON feasibility result."
+        )
+        args = parser.parse_args()
+
+        result = check_feasibility(args.instance_path, args.solution_path, args.result_path)
+        status = "FEASIBLE" if result["feasible"] else "INFEASIBLE"
+        print(f"Result: {status}")
+        if not result["feasible"]:
+            print(f"Violated constraints: {result['violated_constraints']}")
+            for v in result["violations"]:
+                print(f"  - {v}")
+    except Exception as _frontieror_unexpected_error:
+        if not _frontieror_write_unexpected_rejection(
+            _frontieror_unexpected_error
+        ):
+            raise

tasks/elci2022/gurobi_code.py

@@ -0,0 +1,291 @@
+"""
+Deterministic Equivalent MILP for Stochastic Planning and Scheduling
+Paper: "Stochastic Planning and Scheduling with Logic-Based Benders Decomposition"
+       Elci & Hooker (2020)
+Model: Eq. (22) – Minimum Makespan variant
+
+Usage:
+    python gurobi_code.py --instance_path instance_1.json \
+                          --solution_path gurobi_solution_1.json \
+                          --time_limit 3600
+"""
+
+import argparse
+import json
+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
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def compute_time_horizon(n, m, S, r, p):
+    """
+    Upper bound on the scheduling horizon.
+    NOT SPECIFIED IN PAPER exactly.
+    INFERRED ASSUMPTION: T_max = max_j(r_j) + sum_j(max_{i,omega}(p^omega_ij)).
+    This is a valid upper bound because even if all jobs run sequentially
+    starting from the latest release time, the makespan cannot exceed this value.
+    """
+    max_release = max(r)
+    # For each job, the largest processing time across all facilities and scenarios
+    max_proc_per_job = [
+        max(p[omega][i][j] for i in range(m) for omega in range(S))
+        for j in range(n)
+    ]
+    return max_release + sum(max_proc_per_job)
+
+
+# ---------------------------------------------------------------------------
+# Main solver
+# ---------------------------------------------------------------------------
+
+def solve(instance_path, solution_path, time_limit):
+    # ---- Load instance ----
+    with open(instance_path) as f:
+        inst = json.load(f)
+
+    n   = inst["n"]                        # number of jobs
+    m   = inst["m"]                        # number of facilities
+    S   = inst["num_scenarios"]
+    K   = inst["facility_capacity_limits"] # K[i]
+    c   = inst["capacity_requirements"]    # c[i][j]
+    r   = inst["release_times"]            # r[j]
+    scenarios = inst["scenarios"]
+    pi  = [sc["probability"] for sc in scenarios]
+    p   = [sc["processing_times"] for sc in scenarios]  # p[omega][i][j]
+
+    T_max = compute_time_horizon(n, m, S, r, p)
+
+    # ---- Build model ----
+    model = gp.Model("DetEquivMILP")
+    model.setParam("Threads", 1)
+    model.setParam("TimeLimit", time_limit)
+    model.setParam("MIPFocus", 1)
+    model.setParam("NoRelHeurTime", min(60.0, time_limit * 0.05))
+
+    # ----------------------------------------------------------------
+    # Variables
+    # ----------------------------------------------------------------
+
+    # x[i,j] in {0,1}: 1 if job j assigned to facility i  (Eq. 22d)
+    x = {}
+    for i in range(m):
+        for j in range(n):
+            x[i, j] = model.addVar(vtype=GRB.BINARY, name=f"x_{i}_{j}")
+
+    # beta[omega] >= 0: scenario-level makespan surrogate  (Eq. 22a)
+    beta = {
+        omega: model.addVar(lb=0.0, name=f"beta_{omega}")
+        for omega in range(S)
+    }
+
+    # beta_iw[i,omega] >= 0: facility–scenario makespan surrogate  (Eq. 22c)
+    beta_iw = {
+        (i, omega): model.addVar(lb=0.0, name=f"biw_{i}_{omega}")
+        for i in range(m) for omega in range(S)
+    }
+
+    # z[omega,i,j,t] in {0,1}: 1 if job j starts at time t on facility i, scenario omega
+    # Only create for valid (omega, i, j, t):  r[j] <= t <= T_max - p[omega][i][j]
+    z = {}
+    for omega in range(S):
+        for i in range(m):
+            for j in range(n):
+                p_ij = p[omega][i][j]
+                t_end = T_max - p_ij
+                for t in range(r[j], max(r[j], t_end) + 1):
+                    z[omega, i, j, t] = model.addVar(
+                        vtype=GRB.BINARY, name=f"z_{omega}_{i}_{j}_{t}"
+                    )
+
+    # ----------------------------------------------------------------
+    # Objective  (Eq. 22a): minimize sum_omega pi_omega * beta_omega
+    # ----------------------------------------------------------------
+    model.setObjective(
+        gp.quicksum(pi[omega] * beta[omega] for omega in range(S)),
+        GRB.MINIMIZE
+    )
+
+    # ----------------------------------------------------------------
+    # Constraint (22b): each job assigned to exactly one facility
+    # ----------------------------------------------------------------
+    for j in range(n):
+        model.addConstr(
+            gp.quicksum(x[i, j] for i in range(m)) == 1,
+            name=f"assign_{j}"
+        )
+
+    # ----------------------------------------------------------------
+    # Constraint (22c): beta_omega >= beta_iw[i,omega]
+    # ----------------------------------------------------------------
+    for omega in range(S):
+        for i in range(m):
+            model.addConstr(
+                beta[omega] >= beta_iw[i, omega],
+                name=f"betadecomp_{omega}_{i}"
+            )
+
+    # ----------------------------------------------------------------
+    # Constraint (22e): beta_iw[i,omega] >= finish time of job j on facility i
+    # beta_iw[i,omega] >= sum_t (t + p_ij) * z_ijt   for all i, j, omega
+    # Note: z_ijt = 0 when job j is NOT assigned to facility i (from constraint f),
+    # so this properly bounds the facility makespan.
+    # ----------------------------------------------------------------
+    for omega in range(S):
+        for i in range(m):
+            for j in range(n):
+                p_ij = p[omega][i][j]
+                valid = [
+                    (t, z[omega, i, j, t])
+                    for t in range(r[j], T_max - p_ij + 1)
+                    if (omega, i, j, t) in z
+                ]
+                if valid:
+                    model.addConstr(
+                        beta_iw[i, omega] >= gp.quicksum(
+                            (t + p_ij) * zv for t, zv in valid
+                        ),
+                        name=f"mksp_{omega}_{i}_{j}"
+                    )
+
+    # ----------------------------------------------------------------
+    # Constraint (22f): z_ijt <= x_ij
+    # ----------------------------------------------------------------
+    for (omega, i, j, t), zv in z.items():
+        model.addConstr(zv <= x[i, j], name=f"link_{omega}_{i}_{j}_{t}")
+
+    # ----------------------------------------------------------------
+    # Constraint (22g): each job scheduled in exactly one (facility, time) slot
+    #                   per scenario
+    # ----------------------------------------------------------------
+    for omega in range(S):
+        for j in range(n):
+            model.addConstr(
+                gp.quicksum(
+                    z[omega, i, j, t]
+                    for i in range(m)
+                    for t in range(r[j], T_max - p[omega][i][j] + 1)
+                    if (omega, i, j, t) in z
+                ) == 1,
+                name=f"sched_{omega}_{j}"
+            )
+
+    # ----------------------------------------------------------------
+    # Constraint (22h): cumulative resource capacity at each time point.
+    #
+    # Paper states: T^omega_tij = {t' | 0 <= t' <= t - p^omega_ij}
+    # However, applying the standard cumulative constraint interpretation,
+    # job j (started at t') is ACTIVE at time t if t' <= t < t' + p_ij,
+    # i.e., t - p_ij + 1 <= t' <= t.
+    #
+    # INFERRED ASSUMPTION: We use the standard cumulative formulation where
+    # job j is active at time t iff its start time t' satisfies
+    # max(r_j, t - p_ij + 1) <= t' <= t. This is the correct formulation
+    # for a cumulative resource constraint and matches the CP subproblem (11).
+    # ----------------------------------------------------------------
+    for omega in range(S):
+        for i in range(m):
+            for t in range(T_max + 1):
+                parts = []
+                for j in range(n):
+                    p_ij = p[omega][i][j]
+                    t_lo = max(r[j], t - p_ij + 1)
+                    t_hi = t
+                    for t_prime in range(t_lo, t_hi + 1):
+                        if (omega, i, j, t_prime) in z:
+                            parts.append(c[i][j] * z[omega, i, j, t_prime])
+                if parts:
+                    model.addConstr(
+                        gp.quicksum(parts) <= K[i],
+                        name=f"cap_{omega}_{i}_{t}"
+                    )
+
+    # ----------------------------------------------------------------
+    # Solve
+    # ----------------------------------------------------------------
+    model.optimize()
+
+    # ----------------------------------------------------------------
+    # Extract and write solution
+    # ----------------------------------------------------------------
+    result = {
+        "objective_value": None,
+        "status": "no_solution",
+    }
+
+    if model.SolCount > 0:
+        result["objective_value"] = model.ObjVal
+        result["status"] = "optimal" if model.status == GRB.OPTIMAL else "time_limit"
+
+        assignment = {}
+        for j in range(n):
+            for i in range(m):
+                if x[i, j].X > 0.5:
+                    assignment[str(j)] = i
+        result["assignment"] = assignment
+
+        schedule = {}
+        for omega in range(S):
+            schedule[str(omega)] = {}
+            for j in range(n):
+                for i in range(m):
+                    for t in range(r[j], T_max + 1):
+                        if (omega, i, j, t) in z and z[omega, i, j, t].X > 0.5:
+                            schedule[str(omega)][str(j)] = {
+                                "facility": i,
+                                "start": t,
+                                "finish": t + p[omega][i][j],
+                            }
+        result["schedule"] = schedule
+
+    with open(solution_path, "w") as f:
+        result["runtime"] = time.time() - _GUROBI_CODE_START_TIME
+        json.dump(result, f, indent=2)
+
+    print(f"Objective value : {result['objective_value']}")
+    print(f"Status          : {result['status']}")
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Solve stochastic planning & scheduling via deterministic "
+                    "equivalent MILP (Eq. 22, Elci & Hooker 2020)."
+    )
+    parser.add_argument(
+        "--instance_path", required=True,
+        help="Path to the JSON instance file."
+    )
+    parser.add_argument(
+        "--solution_path", required=True,
+        help="Path where the solution JSON will be written."
+    )
+    parser.add_argument(
+        "--time_limit", type=int, required=True,
+        help="Maximum solver time 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)
+
+    solve(args.instance_path, args.solution_path, args.time_limit)

tasks/elci2022/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/elci2022/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/elci2022/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/elci2022/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/elci2022/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/elci2022/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/elci2022/gurobi_solution/large_solution_1.json

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

tasks/elci2022/gurobi_solution/large_solution_2.json

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

tasks/elci2022/gurobi_solution/large_solution_3.json

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

tasks/elci2022/gurobi_solution/large_solution_4.json

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

tasks/elci2022/gurobi_solution/large_solution_5.json

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

tasks/elci2022/gurobi_solution/tiny_solution.json

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

tasks/elci2022/gurobi_solution_log/large_log_1.jsonl

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

tasks/elci2022/gurobi_solution_log/large_log_2.jsonl

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

tasks/elci2022/gurobi_solution_log/large_log_3.jsonl

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

tasks/elci2022/gurobi_solution_log/large_log_4.jsonl

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

tasks/elci2022/gurobi_solution_log/large_log_5.jsonl

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

tasks/elci2022/gurobi_solution_log/tiny_log.jsonl

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

tasks/elci2022/instance/large_instance_1.json

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

tasks/elci2022/instance/large_instance_2.json

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

tasks/elci2022/instance/large_instance_3.json

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

tasks/elci2022/instance/large_instance_4.json

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

tasks/elci2022/instance/large_instance_5.json

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

tasks/elci2022/instance/tiny_instance.json

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

tasks/elci2022/instance_schema.json

@@ -0,0 +1,15 @@
+{
+  "n": "<int> Number of jobs to be processed.",
+  "m": "<int> Number of facilities available for processing jobs.",
+  "num_scenarios": "<int> Number of uncertain processing-time scenarios considered.",
+  "facility_capacity_limits": "<list[int], length m> Maximum resource capacity of each facility at any point in time.",
+  "capacity_requirements": "<list[list[int]], shape [m][n]> Resource consumption rate of each job when processed on each facility.",
+  "release_times": "<list[int], length n> Earliest time at which each job may begin processing.",
+  "mean_processing_times": "<list[list[int]], shape [m][n]> Nominal processing time of each job on each facility before scenario-based perturbation.",
+  "scenarios": [
+    {
+      "probability": "<float> Likelihood of this scenario occurring.",
+      "processing_times": "<list[list[int]], shape [m][n]> Realized processing time of each job on each facility under this scenario."
+    }
+  ]
+}

tasks/elci2022/mathematical_formulation.md

@@ -0,0 +1,56 @@
+# Original Formulation: Two-Stage Stochastic Planning and Scheduling
+
+*Source: Stochastic Planning and Scheduling with Logic-Based Benders Decomposition, Özgün Elçi and J. N. Hooker, 2020/2022.*
+
+## Sets and Parameters
+
+- $J$: set of jobs, indexed by $j$.
+
+- $I$: set of facilities, indexed by $i$.
+
+- $\Omega$: finite set of scenarios, indexed by $\omega$; $\pi_\omega \ge 0$ is the probability of scenario $\omega$, with $\sum_{\omega \in \Omega} \pi_\omega = 1$.
+
+- $p^{\omega}_{ij}$: processing time of job $j$ on facility $i$ in scenario $\omega$.
+
+- $r_j$: release time of job $j$.
+
+- $d_j$: deadline of job $j$; each job must be processed within $[r_j, d_j]$.
+
+- $c_{ij}$: resource consumption of job $j$ on facility $i$ (cumulative scheduling).
+
+- $K_i$: maximum total resource consumption on facility $i$ at any instant.
+
+- $g(\mathbf{x})$: first-stage cost as a function of the assignment.
+
+- $h(\mathbf{s},\mathbf{x},\omega)$: second-stage objective.
+
+## Decision Variables
+
+- **First-stage (binary)**: $x_j \in I$ for all $j \in J$, i.e. $x_j$ denotes the facility to which job $j$ is assigned. Equivalently, $x_{ij} \in \{0,1\}$ with $x_{ij} = 1$ iff job $j$ is assigned to facility $i$. For each $\mathbf{x}$, let $J_i(\mathbf{x}) = \{j \in J : x_j = i\}$ denote the set of jobs assigned to facility $i$.
+
+- **Second-stage (continuous)**: $s_j \ge 0$ for all $j \in J$, the start time of job $j$; $s_j$ is determined after the scenario $\omega$ is revealed.
+
+## Objective
+
+$$\begin{align}
+\min_{\mathbf{x}} \quad & g(\mathbf{x}) + \sum_{\omega \in \Omega} \pi_\omega\, Q(\mathbf{x}, \omega)
+  \;:\; x_j \in I,\ \forall j \in J, \tag{3}
+\end{align}$$ where the second-stage value is $$\begin{align}
+Q(\mathbf{x}, \omega) = \min_{\mathbf{s}} \quad & h(\mathbf{s}, \mathbf{x}, \omega) \tag{2}
+\end{align}$$ *(With (1): $\min_{\mathbf{x}\in X}\{f(\mathbf{x}) + \mathbb{E}_{\omega}[Q(\mathbf{x},\omega)]\}$.)*
+
+## Constraints of the Second Stage (for each scenario $\omega \in \Omega$)
+
+$$\begin{align}
+s_j \in [\, r_j,\; d_j - p^{\omega}_{x_j,j} \,],
+  & \quad \forall j \in J, \tag{TW}\\
+\sum_{\substack{j \in J_i(\mathbf{x}) \\ 0 \le t \le s_j + p^{\omega}_{x_j,j}}} c_{ij} \le K_i,
+  & \quad \forall i \in I,\; \forall t \ge 0. \tag{CUM}
+\end{align}$$ Here (TW) are the time-window constraints ensuring each job finishes before its deadline under its (scenario-dependent) processing time. The cumulative resource constraint (CUM) states that, at every point in time $t$, the total resource consumption of jobs being processed on facility $i$ must not exceed $K_i$. Each assignment $\mathbf{x}$ induces, for every $(\omega, i)$, a cumulative scheduling problem over the jobs in $J_i(\mathbf{x})$ with continuous start-time variables $s_j$.
+
+## First-Stage Constraints
+
+$$\begin{align}
+\sum_{i \in I} x_{ij} &= 1, & \forall j \in J, \notag\\
+x_{ij} &\in \{0,1\}, & \forall i \in I,\; j \in J. \notag
+\end{align}$$

tasks/elci2022/problem_description.txt

@@ -0,0 +1,7 @@
+# Problem Description
+
+A company operates a set of facilities and must process a set of jobs under uncertainty. Processing times are uncertain and modeled through a finite set of scenarios, each with a known probability. The input data specifies, for each facility, a resource capacity limit. For each combination of job and facility, the data provides a resource consumption rate and a scenario-dependent processing time. Each job also has a release time before which it cannot begin processing. Jobs have no deadlines.
+
+The company must make two types of decisions. First, before the uncertain processing times are revealed, each job must be assigned to exactly one facility. Second, after a scenario is realized, the jobs assigned to each facility must be scheduled by choosing a start time for each job. A job's start time must be no earlier than its release time. Multiple jobs may run simultaneously on the same facility, but at every point in time the total resource consumption of all jobs whose processing intervals overlap that time point must not exceed the facility's resource capacity. Specifically, a job assigned to a given facility occupies resources from its start time until its start time plus its processing time on that facility under the realized scenario, and during this entire interval the job's resource consumption counts toward the facility's capacity limit.
+
+The goal is to minimize the expected makespan across all scenarios. The makespan under a given scenario is the latest completion time among all jobs, where a job's completion time equals its start time plus its processing time on its assigned facility under that scenario. The expected makespan is the probability-weighted sum of the scenario makespans. There is no first-stage assignment cost, so the entire objective consists of this expected makespan.

tasks/elci2022/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/elci2022/solution_schema.json

@@ -0,0 +1,13 @@
+{
+  "objective_value": "<float> Expected makespan across all scenarios, weighted by scenario probabilities.",
+  "assignment": "<dict, key: '{job}'> Facility to which each job is assigned before uncertainty is revealed.",
+  "schedule": {
+    "{scenario}": {
+      "{job}": {
+        "facility": "<int> Facility on which this job is processed in this scenario.",
+        "start": "<int> Time at which this job begins processing in this scenario.",
+        "finish": "<int> Time at which this job completes processing in this scenario."
+      }
+    }
+  }
+}

tasks/engineer2012/feasibility_check.py

@@ -0,0 +1,963 @@
+#!/usr/bin/env python3
+"""
+Feasibility Checker for Single-Product Maritime Inventory Routing.
+
+Checks hard constraints from the mathematical formulation in Engineer et al. (2012):
+  "A Branch-Price-and-Cut Algorithm for Single-Product Maritime Inventory Routing"
+
+Constraints checked (numbered as in the paper formulation):
+  (1) Inventory balance at supply ports
+  (2) Inventory balance at demand ports
+  (3) Storage capacity bounds: 0 <= I_{j,t} <= Q_{j,t}
+  (4) Convexity: each vessel executes exactly one voyage (sum lambda = 1)
+  (5) Non-negativity: lambda >= 0
+  (6) Integrality of load/discharge decisions (z in {0,1})
+  (7) Flow conservation (path from source to sink)
+  (8) Load/discharge only if node is visited
+  (9) Load/discharge quantity bounds: F_min * z <= |f| <= F_max * z
+  (10) Vessel inventory tracking along path
+  (11) Vessel inventory capacity: 0 <= F_n <= U_n
+  (12) Arc integrality
+  (13) Load/discharge decision integrality (z in {0,1})
+
+Usage:
+  python feasibility_check.py --instance_path instance_1.json \
+      --solution_path efficient_solution_1.json \
+      --result_path efficient_feasi_result_1.json
+"""
+
+import argparse
+import ast
+import json
+import math
+import sys
+from collections import defaultdict
+
+# FRONTIEROR_RELEASE_CONTRACT_V2
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('cost_breakdown', 'objective_value', 'port_inventories', 'vessel_operations', 'vessel_routes')
+_FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ('cost_breakdown', 'objective_value', 'port_inventories', 'vessel_routes')
+_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:
+                if operation == "assignment_key_set":
+                    reported_set = set(solution[target])
+                    expected_set = {entry[source_key] for entry in solution[source]}
+                    if reported_set != expected_set:
+                        violations.append(
+                            f"{target}={sorted(reported_set)} does not match the "
+                            f"decision-derived value {sorted(expected_set)}"
+                        )
+                    continue
+
+                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 load_json(path):
+    with open(path, 'r') as f:
+        return json.load(f)
+
+
+def parse_instance(data):
+    """Parse instance data into a structured format."""
+    T = data["planning_horizon"]
+    vessels = {}
+    for v in data["vessels"]:
+        vessels[v["id"]] = {
+            "id": v["id"],
+            "capacity": v["capacity"],
+            "avail_start": v["availability_start"],
+            "avail_end": v["availability_end"],
+            "initial_load": v.get("initial_load", 0),
+            "transport_cost_per_day": v["transport_cost_per_day"],
+            "demurrage_cost_per_day": v["demurrage_cost_per_day"],
+        }
+
+    supply_ports = {}
+    for sp in data["supply_ports"]:
+        supply_ports[sp["port_id"]] = {
+            "port_id": sp["port_id"],
+            "type": "supply",
+            "initial_inventory": sp["initial_inventory"],
+            "rates": sp["production_rate"],
+            "storage_capacity": sp["storage_capacity"],
+            "F_min": sp["F_min"],
+            "F_max": sp["F_max"],
+            "unit_cost": sp["unit_procurement_cost"],
+        }
+
+    demand_ports = {}
+    for dp in data["demand_ports"]:
+        demand_ports[dp["port_id"]] = {
+            "port_id": dp["port_id"],
+            "type": "demand",
+            "initial_inventory": dp["initial_inventory"],
+            "rates": dp["consumption_rate"],
+            "storage_capacity": dp["storage_capacity"],
+            "F_min": dp["F_min"],
+            "F_max": dp["F_max"],
+            "unit_cost": dp["unit_supply_revenue"],
+        }
+
+    travel_times = {}
+    for key, val in data["travel_times"].items():
+        a, b = key.split("->")
+        travel_times[(a, b)] = val
+
+    draft_limits = {}
+    for key, val in data.get("draft_limits", {}).items():
+        a, b = key.split("->")
+        draft_limits[(a, b)] = val
+
+    return T, vessels, supply_ports, demand_ports, travel_times, draft_limits
+
+
+def parse_solution(sol_data, vessels_info):
+    """Parse the serialized operation witness for every vessel."""
+    vessel_visits = {}
+    operations = sol_data["vessel_operations"]
+    for vid in vessels_info:
+        visits = []
+        for op in operations.get(vid, []):
+            visits.append({
+                "port": op["port"],
+                "time": int(op["time"]),
+                "load_discharge": float(op["quantity"]),
+                "type": op["type"],
+            })
+        visits.sort(key=lambda visit: visit["time"])
+        vessel_visits[vid] = visits
+    return vessel_visits
+
+
+def parse_route_node(serialized):
+    """Parse the tuple representation emitted by gurobi_code.py."""
+    node = ast.literal_eval(serialized)
+    if not isinstance(node, tuple) or len(node) != 2:
+        raise ValueError(f"invalid route node {serialized!r}")
+    return node
+
+
+def check_feasibility(instance_data, solution_data):
+    """Check all hard constraints and return violations."""
+    tol = 1e-5
+    eps = 1e-5
+
+    T, vessels, supply_ports, demand_ports, travel_times, draft_limits = \
+        parse_instance(instance_data)
+
+    vessel_visits = parse_solution(solution_data, vessels)
+
+    all_ports = {}
+    all_ports.update(supply_ports)
+    all_ports.update(demand_ports)
+
+    violations = []
+    violation_magnitudes = []
+
+    def add_violation(constraint_idx, message, lhs, rhs, violation_amount):
+        normalizer = max(abs(rhs), eps)
+        ratio = violation_amount / normalizer
+        violations.append((constraint_idx, message))
+        violation_magnitudes.append({
+            "constraint": constraint_idx,
+            "lhs": lhs,
+            "rhs": rhs,
+            "raw_excess": violation_amount,
+            "normalizer": normalizer,
+            "ratio": ratio,
+        })
+
+    # =====================================================================
+    # Constraints (7), (8), (10), and (12): validate the complete serialized
+    # source-to-sink path, arc timing, operation support, and commodity flow.
+    # Route entries are unordered in the JSON, so first reconstruct the path.
+    # =====================================================================
+    expected_vessels = set(vessels)
+    route_witness = solution_data["vessel_routes"]
+    operation_witness = solution_data["vessel_operations"]
+    if set(route_witness) != expected_vessels:
+        add_violation(
+            7,
+            "vessel_routes keys do not exactly cover the instance vessels",
+            float(len(route_witness)), float(len(expected_vessels)), 1.0,
+        )
+    if set(operation_witness) != expected_vessels:
+        add_violation(
+            8,
+            "vessel_operations keys do not exactly cover the instance vessels",
+            float(len(operation_witness)), float(len(expected_vessels)), 1.0,
+        )
+
+    transport_cost = 0.0
+    demurrage_cost = 0.0
+    for vid, vessel in vessels.items():
+        source = ("src", vid)
+        sink = ("snk", vid)
+        serialized_arcs = route_witness.get(vid, [])
+        parsed_arcs = []
+        route_nodes = set()
+
+        for arc_position, arc in enumerate(serialized_arcs):
+            try:
+                tail = parse_route_node(arc["tail"])
+                head = parse_route_node(arc["head"])
+                arc_type = arc["type"]
+                reported_cost = float(arc["cost"])
+                product_flow = float(arc["product_flow"])
+                if not all(math.isfinite(value) for value in
+                           (reported_cost, product_flow)):
+                    raise ValueError("arc cost/product_flow is not finite")
+            except (KeyError, TypeError, ValueError, SyntaxError) as error:
+                add_violation(
+                    12,
+                    f"Vessel {vid} route arc {arc_position} is malformed: {error}",
+                    1.0, 0.0, 1.0,
+                )
+                continue
+
+            def is_port_time(node):
+                return (
+                    node[0] in all_ports
+                    and isinstance(node[1], int)
+                    and not isinstance(node[1], bool)
+                    and vessel["avail_start"] <= node[1] <= vessel["avail_end"]
+                )
+
+            canonical_cost = None
+            valid_arc = True
+            if arc_type == "source":
+                valid_arc = (
+                    tail == source
+                    and is_port_time(head)
+                    and head[1] == vessel["avail_start"]
+                )
+                canonical_cost = 0.0
+            elif arc_type == "sink":
+                valid_arc = is_port_time(tail) and head == sink
+                canonical_cost = 0.0
+            elif arc_type == "demurrage":
+                valid_arc = (
+                    is_port_time(tail)
+                    and is_port_time(head)
+                    and tail[0] == head[0]
+                    and head[1] == tail[1] + 1
+                )
+                canonical_cost = float(vessel["demurrage_cost_per_day"])
+            elif arc_type == "travel":
+                travel_time = travel_times.get((tail[0], head[0]))
+                valid_arc = (
+                    is_port_time(tail)
+                    and is_port_time(head)
+                    and tail[0] != head[0]
+                    and travel_time is not None
+                    and head[1] == tail[1] + travel_time
+                )
+                if travel_time is not None:
+                    canonical_cost = (
+                        float(vessel["transport_cost_per_day"])
+                        * float(travel_time)
+                    )
+            else:
+                valid_arc = False
+
+            if not valid_arc or canonical_cost is None:
+                add_violation(
+                    7,
+                    f"Vessel {vid} contains an invalid {arc_type!r} arc "
+                    f"{tail!r} -> {head!r}",
+                    1.0, 0.0, 1.0,
+                )
+                continue
+            if abs(reported_cost - canonical_cost) > tol:
+                add_violation(
+                    7,
+                    f"Vessel {vid} arc {tail!r}->{head!r} reports cost "
+                    f"{reported_cost}, expected {canonical_cost}",
+                    reported_cost, canonical_cost,
+                    abs(reported_cost - canonical_cost),
+                )
+            if product_flow < -tol:
+                add_violation(
+                    10,
+                    f"Vessel {vid} has negative product flow on "
+                    f"{tail!r}->{head!r}",
+                    product_flow, 0.0, -product_flow,
+                )
+
+            endpoint_limits = []
+            for node in (tail, head):
+                if is_port_time(node):
+                    endpoint_limits.append(min(
+                        vessel["capacity"],
+                        draft_limits.get((vid, node[0]), vessel["capacity"]),
+                    ))
+            flow_limit = min(endpoint_limits, default=vessel["capacity"])
+            if product_flow > flow_limit + tol:
+                add_violation(
+                    11,
+                    f"Vessel {vid} product flow {product_flow} exceeds arc "
+                    f"capacity {flow_limit} on {tail!r}->{head!r}",
+                    product_flow, flow_limit, product_flow - flow_limit,
+                )
+
+            parsed_arcs.append({
+                "tail": tail,
+                "head": head,
+                "type": arc_type,
+                "flow": product_flow,
+            })
+            route_nodes.update((tail, head))
+            if arc_type == "travel":
+                transport_cost += canonical_cost
+            elif arc_type == "demurrage":
+                demurrage_cost += canonical_cost
+
+        outgoing = defaultdict(list)
+        incoming = defaultdict(list)
+        for arc in parsed_arcs:
+            outgoing[arc["tail"]].append(arc)
+            incoming[arc["head"]].append(arc)
+        structural_error = False
+        for node in route_nodes | {source, sink}:
+            expected_in = 0 if node == source else 1
+            expected_out = 0 if node == sink else 1
+            if len(incoming[node]) != expected_in or len(outgoing[node]) != expected_out:
+                structural_error = True
+                add_violation(
+                    7,
+                    f"Vessel {vid} route degree is invalid at {node!r}: "
+                    f"in={len(incoming[node])}, out={len(outgoing[node])}",
+                    float(len(incoming[node]) + len(outgoing[node])),
+                    float(expected_in + expected_out), 1.0,
+                )
+
+        if not structural_error:
+            traversed = []
+            current = source
+            while current != sink and len(traversed) <= len(parsed_arcs):
+                arc = outgoing[current][0]
+                traversed.append(arc)
+                current = arc["head"]
+            if current != sink or len(traversed) != len(parsed_arcs):
+                add_violation(
+                    7,
+                    f"Vessel {vid} selected arcs do not form one complete "
+                    "source-to-sink path",
+                    float(len(traversed)), float(len(parsed_arcs)), 1.0,
+                )
+
+        operation_by_node = {}
+        for visit in vessel_visits[vid]:
+            node = (visit["port"], visit["time"])
+            if node in operation_by_node:
+                continue  # Constraint 6 records the duplicate below.
+            operation_by_node[node] = visit["load_discharge"]
+            expected_type = (
+                "load" if visit["port"] in supply_ports else "discharge"
+            )
+            if visit["type"] != expected_type:
+                add_violation(
+                    8,
+                    f"Vessel {vid} operation at {node!r} has type "
+                    f"{visit['type']!r}, expected {expected_type!r}",
+                    1.0, 0.0, 1.0,
+                )
+            if node not in outgoing:
+                add_violation(
+                    8,
+                    f"Vessel {vid} operation at {node!r} is not supported by "
+                    "a selected route visit",
+                    1.0, 0.0, 1.0,
+                )
+
+        if len(outgoing[source]) == 1:
+            source_flow = outgoing[source][0]["flow"]
+            if abs(source_flow - vessel["initial_load"]) > tol:
+                add_violation(
+                    10,
+                    f"Vessel {vid} source flow {source_flow} does not match "
+                    f"initial load {vessel['initial_load']}",
+                    source_flow, vessel["initial_load"],
+                    abs(source_flow - vessel["initial_load"]),
+                )
+        for node in route_nodes - {source, sink}:
+            if len(incoming[node]) != 1 or len(outgoing[node]) != 1:
+                continue
+            incoming_flow = incoming[node][0]["flow"]
+            outgoing_flow = outgoing[node][0]["flow"]
+            operation = operation_by_node.get(node, 0.0)
+            flow_difference = abs(incoming_flow + operation - outgoing_flow)
+            if flow_difference > 1e-3:
+                add_violation(
+                    10,
+                    f"Vessel {vid} commodity flow is inconsistent at "
+                    f"{node!r}: incoming {incoming_flow} + operation "
+                    f"{operation} != outgoing {outgoing_flow}",
+                    incoming_flow + operation, outgoing_flow, flow_difference,
+                )
+
+    # =====================================================================
+    # Compute net load/discharge at each (port, time) across all vessels
+    # f_total[port_id][t] = sum over vessels of f_{j,t}^{v,r}
+    # For supply ports: f > 0 means loading (removing from port inventory)
+    # For demand ports: f < 0 means discharging (adding to port inventory)
+    # In the model: I_{j,t} = I_{j,t-1} + b_{j,t} - sum_v f_{j,t}
+    # =====================================================================
+    f_total = defaultdict(lambda: defaultdict(float))
+    for vid, visits in vessel_visits.items():
+        for visit in visits:
+            f_total[visit["port"]][visit["time"]] += visit["load_discharge"]
+
+    # =====================================================================
+    # Compute port inventories
+    # =====================================================================
+    port_inventory = {}  # port_inventory[port_id][t] for t=0..T
+    for pid, port in all_ports.items():
+        inv = [0.0] * (T + 1)
+        inv[0] = port["initial_inventory"]
+        for t in range(1, T + 1):
+            if port["type"] == "supply":
+                # Constraint (1): I_{j,t} = I_{j,t-1} + b_{j,t} - sum_v f_{j,t}
+                inv[t] = inv[t - 1] + port["rates"][t - 1] - f_total[pid][t]
+            else:
+                # Constraint (2): I_{j,t} = I_{j,t-1} - b_{j,t} - sum_v f_{j,t}
+                # For demand: f < 0 for discharge, so -f > 0 adds to inventory
+                inv[t] = inv[t - 1] - port["rates"][t - 1] - f_total[pid][t]
+        port_inventory[pid] = inv
+
+    # The reported inventory trajectory is a derived witness and must cover
+    # every port/time exactly; otherwise a candidate could alter operations
+    # while leaving an unrelated inventory summary in the JSON.
+    reported_inventories = solution_data["port_inventories"]
+    if set(reported_inventories) != set(all_ports):
+        add_violation(
+            1,
+            "port_inventories keys do not exactly cover all instance ports",
+            float(len(reported_inventories)), float(len(all_ports)), 1.0,
+        )
+    for pid in all_ports:
+        entries = reported_inventories.get(pid, [])
+        by_time = {}
+        for entry in entries:
+            time_value = int(entry["time"])
+            if time_value in by_time:
+                add_violation(
+                    1,
+                    f"Port {pid} reports inventory twice at t={time_value}",
+                    2.0, 1.0, 1.0,
+                )
+            by_time[time_value] = float(entry["inventory"])
+        expected_times = set(range(1, T + 1))
+        if set(by_time) != expected_times:
+            add_violation(
+                1,
+                f"Port {pid} inventory times do not exactly cover 1..{T}",
+                float(len(by_time)), float(T), 1.0,
+            )
+        for time_value in expected_times & set(by_time):
+            difference = abs(
+                by_time[time_value] - port_inventory[pid][time_value]
+            )
+            if difference > 1e-3:
+                add_violation(
+                    1,
+                    f"Port {pid} reported inventory {by_time[time_value]} at "
+                    f"t={time_value}, expected {port_inventory[pid][time_value]}",
+                    by_time[time_value], port_inventory[pid][time_value],
+                    difference,
+                )
+
+    # =====================================================================
+    # Constraint (1): Inventory balance at supply ports
+    # I_{j,t} = I_{j,t-1} + b_{j,t} - sum_v f_{j,t}
+    # This is an equality constraint. We check it by verifying the computed
+    # inventory is consistent (it's computed directly, so the balance holds
+    # by construction). The real check is whether the inventory stays within
+    # bounds (Constraint 3). However, we still verify the balance equation
+    # holds as an equality for supply ports.
+    # =====================================================================
+    for pid, port in supply_ports.items():
+        for t in range(1, T + 1):
+            I_prev = port_inventory[pid][t - 1]
+            b_jt = port["rates"][t - 1]
+            f_sum = f_total[pid][t]
+            lhs = port_inventory[pid][t]
+            rhs_val = I_prev + b_jt - f_sum
+            diff = abs(lhs - rhs_val)
+            if diff > tol:
+                add_violation(
+                    1,
+                    f"Supply port {pid} inventory balance violated at t={t}: "
+                    f"I[t]={lhs:.4f} != I[t-1]+b-f = {rhs_val:.4f}",
+                    lhs, rhs_val, diff
+                )
+
+    # =====================================================================
+    # Constraint (2): Inventory balance at demand ports
+    # I_{j,t} = I_{j,t-1} - b_{j,t} - sum_v f_{j,t}
+    # =====================================================================
+    for pid, port in demand_ports.items():
+        for t in range(1, T + 1):
+            I_prev = port_inventory[pid][t - 1]
+            b_jt = port["rates"][t - 1]
+            f_sum = f_total[pid][t]
+            lhs = port_inventory[pid][t]
+            rhs_val = I_prev - b_jt - f_sum
+            diff = abs(lhs - rhs_val)
+            if diff > tol:
+                add_violation(
+                    2,
+                    f"Demand port {pid} inventory balance violated at t={t}: "
+                    f"I[t]={lhs:.4f} != I[t-1]-b-f = {rhs_val:.4f}",
+                    lhs, rhs_val, diff
+                )
+
+    # =====================================================================
+    # Constraint (3): Storage capacity bounds: 0 <= I_{j,t} <= Q_{j,t}
+    # This is two inequalities: I_{j,t} >= 0 and I_{j,t} <= Q_{j,t}
+    # =====================================================================
+    for pid, port in all_ports.items():
+        for t in range(1, T + 1):
+            inv = port_inventory[pid][t]
+            Q_jt = port["storage_capacity"][t - 1]
+
+            # Lower bound: I_{j,t} >= 0  =>  LHS = -I_{j,t}, RHS = 0 (<=)
+            # Or equivalently: 0 <= I_{j,t}, violation if I_{j,t} < 0
+            if inv < -tol:
+                violation_amount = -inv  # how much below 0
+                add_violation(
+                    3,
+                    f"Port {pid} inventory below 0 at t={t}: "
+                    f"I={inv:.4f} < 0",
+                    inv, 0.0, violation_amount
+                )
+
+            # Upper bound: I_{j,t} <= Q_{j,t}
+            if inv > Q_jt + tol:
+                violation_amount = inv - Q_jt
+                add_violation(
+                    3,
+                    f"Port {pid} inventory exceeds capacity at t={t}: "
+                    f"I={inv:.4f} > Q={Q_jt:.4f}",
+                    inv, Q_jt, violation_amount
+                )
+
+    # =====================================================================
+    # Constraint (4): Convexity - each vessel has exactly one voyage
+    # sum_{r in R_v} lambda^{v,r} = 1
+    # In the realized solution, each vessel has exactly one schedule.
+    # This is satisfied by construction since the solution specifies
+    # one schedule per vessel. We just verify each vessel is present.
+    # =====================================================================
+    for vid in vessels:
+        # Each vessel should appear in the solution (even if idle)
+        if vid not in vessel_visits:
+            add_violation(
+                4,
+                f"Vessel {vid} has no voyage assigned (convexity constraint)",
+                0.0, 1.0, 1.0
+            )
+
+    # =====================================================================
+    # Constraint (5): Non-negativity: lambda >= 0
+    # Trivially satisfied since the solution represents a realized (integral)
+    # voyage selection with lambda = 1 for the chosen voyage.
+    # No check needed.
+    # =====================================================================
+
+    # =====================================================================
+    # Constraint (6): Integrality on load/discharge decisions
+    # sum_r z_{j,t}^{v,r} lambda^{v,r} in {0,1}
+    # In realized solution, each vessel visits each (port, time) at most once.
+    # Check: no vessel visits the same (port, time) more than once.
+    # =====================================================================
+    for vid, visits in vessel_visits.items():
+        pt_count = defaultdict(int)
+        for visit in visits:
+            key = (visit["port"], visit["time"])
+            pt_count[key] += 1
+        for (port, time), count in pt_count.items():
+            if count > 1:
+                add_violation(
+                    6,
+                    f"Vessel {vid} visits ({port}, t={time}) {count} times "
+                    f"(integrality requires at most 1)",
+                    float(count), 1.0, float(count - 1)
+                )
+
+    # =====================================================================
+    # Constraint (9): Load/discharge quantity bounds
+    # F_n^{min} * z_n <= f_n <= F_n^{max} * z_n
+    # For supply: F_min <= f <= F_max (f > 0 for loading)
+    # For demand: -F_max <= f <= -F_min (f < 0 for discharging)
+    # So |f| must be in [F_min, F_max] when the port is visited (z=1)
+    # =====================================================================
+    for vid, visits in vessel_visits.items():
+        for visit in visits:
+            pid = visit["port"]
+            t = visit["time"]
+            f_val = visit["load_discharge"]
+            port = all_ports[pid]
+            F_min = port["F_min"]
+            F_max = port["F_max"]
+            abs_f = abs(f_val)
+
+            if port["type"] == "supply":
+                # f >= F_min when visiting
+                if f_val < F_min - tol:
+                    violation_amount = F_min - f_val
+                    add_violation(
+                        9,
+                        f"Vessel {vid} at supply port {pid} t={t}: "
+                        f"load={f_val:.4f} < F_min={F_min}",
+                        f_val, F_min, violation_amount
+                    )
+                # f <= F_max when visiting
+                if f_val > F_max + tol:
+                    violation_amount = f_val - F_max
+                    add_violation(
+                        9,
+                        f"Vessel {vid} at supply port {pid} t={t}: "
+                        f"load={f_val:.4f} > F_max={F_max}",
+                        f_val, F_max, violation_amount
+                    )
+            else:
+                # Demand port: f <= 0, |f| >= F_min, |f| <= F_max
+                if f_val > tol:
+                    violation_amount = f_val
+                    add_violation(
+                        9,
+                        f"Vessel {vid} at demand port {pid} t={t}: "
+                        f"load_discharge={f_val:.4f} > 0 (should be <= 0)",
+                        f_val, 0.0, violation_amount
+                    )
+                if abs_f < F_min - tol:
+                    violation_amount = F_min - abs_f
+                    add_violation(
+                        9,
+                        f"Vessel {vid} at demand port {pid} t={t}: "
+                        f"|discharge|={abs_f:.4f} < F_min={F_min}",
+                        abs_f, F_min, violation_amount
+                    )
+                if abs_f > F_max + tol:
+                    violation_amount = abs_f - F_max
+                    add_violation(
+                        9,
+                        f"Vessel {vid} at demand port {pid} t={t}: "
+                        f"|discharge|={abs_f:.4f} > F_max={F_max}",
+                        abs_f, F_max, violation_amount
+                    )
+
+    # =====================================================================
+    # Constraint (11): Vessel inventory capacity: 0 <= F_n <= U_n
+    # Track vessel load along its path. U_n = min(Q_v, draft_limit(v,j))
+    # The vessel starts with initial_load and accumulates f values.
+    #
+    # Per math_model.txt constraint (11): F_n is the vessel inventory
+    # ENTERING node n (before loading/discharging at n). This is defined
+    # by constraint (10): F_n = sum_{e=(n',n)} x_e (F_{n'} + f_{n'}).
+    # Equivalently, from the LP subproblem constraint (14):
+    #   0 <= sum_{i=0}^{k-1} f_{n_i} <= U_{n_k}  for k=1,...,K
+    # which bounds the cumulative load BEFORE operations at node n_k.
+    # =====================================================================
+    for vid, visits in vessel_visits.items():
+        if not visits:
+            continue
+        vessel = vessels[vid]
+        Q_v = vessel["capacity"]
+        load = vessel["initial_load"]
+        for i, visit in enumerate(visits):
+            pid = visit["port"]
+            t = visit["time"]
+            f_val = visit["load_discharge"]
+
+            # Draft limit: U_n bounds the inventory ENTERING the node
+            dl = draft_limits.get((vid, pid), Q_v)
+            U_n = min(Q_v, dl)
+
+            # Check 0 <= load <= U_n BEFORE loading/discharging at this node
+            if load < -tol:
+                violation_amount = -load
+                add_violation(
+                    11,
+                    f"Vessel {vid} has negative load={load:.4f} entering "
+                    f"{pid} at t={t}",
+                    load, 0.0, violation_amount
+                )
+            if load > U_n + tol:
+                violation_amount = load - U_n
+                add_violation(
+                    11,
+                    f"Vessel {vid} load={load:.4f} exceeds capacity "
+                    f"U_n={U_n:.4f} entering {pid} at t={t}",
+                    load, U_n, violation_amount
+                )
+
+            # Update load AFTER checking the constraint
+            load += f_val
+
+    # =====================================================================
+    # Objective and cost summary: every component is derivable from the route
+    # and operation witnesses, so bind both cost_breakdown and objective_value
+    # to those decisions instead of trusting candidate-reported numbers.
+    # =====================================================================
+    procurement_cost = sum(
+        supply_ports[visit["port"]]["unit_cost"]
+        * visit["load_discharge"]
+        for visits in vessel_visits.values()
+        for visit in visits
+        if visit["port"] in supply_ports
+    )
+    supply_revenue = sum(
+        demand_ports[visit["port"]]["unit_cost"]
+        * (-visit["load_discharge"])
+        for visits in vessel_visits.values()
+        for visit in visits
+        if visit["port"] in demand_ports
+    )
+    expected_costs = {
+        "transport_cost": transport_cost,
+        "demurrage_cost": demurrage_cost,
+        "procurement_cost": procurement_cost,
+        "supply_revenue": supply_revenue,
+    }
+    expected_costs["total_cost"] = (
+        transport_cost + demurrage_cost + procurement_cost - supply_revenue
+    )
+    cost_breakdown = solution_data["cost_breakdown"]
+    if set(cost_breakdown) != set(expected_costs):
+        add_violation(
+            14,
+            "cost_breakdown fields do not exactly match the five documented "
+            "cost components",
+            float(len(cost_breakdown)), float(len(expected_costs)), 1.0,
+        )
+    for component, expected_value in expected_costs.items():
+        if component not in cost_breakdown:
+            continue
+        reported_value = float(cost_breakdown[component])
+        difference = abs(reported_value - expected_value)
+        component_tolerance = max(1e-3, 1e-7 * abs(expected_value))
+        if not math.isfinite(reported_value) or difference > component_tolerance:
+            add_violation(
+                14,
+                f"cost_breakdown.{component}={reported_value} does not match "
+                f"the decision-derived value {expected_value}",
+                reported_value, expected_value, difference,
+            )
+
+    reported_objective = float(solution_data["objective_value"])
+    objective_difference = abs(
+        reported_objective - expected_costs["total_cost"]
+    )
+    objective_tolerance = max(
+        1e-3, 1e-7 * abs(expected_costs["total_cost"])
+    )
+    if objective_difference > objective_tolerance:
+        add_violation(
+            14,
+            f"objective_value={reported_objective} does not match the "
+            f"decision-derived total {expected_costs['total_cost']}",
+            reported_objective, expected_costs["total_cost"],
+            objective_difference,
+        )
+
+    # =====================================================================
+    # Compile results
+    # =====================================================================
+    violated_set = sorted(set(c for c, _ in violations))
+    violation_messages = []
+    # Aggregate messages per constraint
+    msgs_by_constraint = defaultdict(list)
+    for c, msg in violations:
+        msgs_by_constraint[c].append(msg)
+    for c in violated_set:
+        msgs = msgs_by_constraint[c]
+        if len(msgs) <= 3:
+            violation_messages.extend(msgs)
+        else:
+            violation_messages.extend(msgs[:2])
+            violation_messages.append(
+                f"... and {len(msgs) - 2} more violation(s) for constraint {c}"
+            )
+
+    feasible = len(violated_set) == 0
+
+    result = {
+        "feasible": feasible,
+        "violated_constraints": violated_set,
+        "violations": violation_messages,
+        "violation_magnitudes": violation_magnitudes if not feasible else [],
+    }
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Feasibility checker for Maritime Inventory Routing")
+    parser.add_argument("--instance_path", required=True,
+                        help="Path to JSON instance file")
+    parser.add_argument("--solution_path", required=True,
+                        help="Path to JSON solution file")
+    parser.add_argument("--result_path", required=True,
+                        help="Path to write JSON feasibility result")
+    args = parser.parse_args()
+
+    instance_data = load_json(args.instance_path)
+    solution_data = load_json(args.solution_path)
+    _frontieror_contract_result = _frontieror_validate_solution_contract(solution_data)
+    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_data, solution_data)
+
+    with open(args.result_path, 'w') as f:
+        json.dump(result, f, indent=2)
+
+    status = "FEASIBLE" if result["feasible"] else "INFEASIBLE"
+    print(f"{status}: {args.solution_path}")
+    if not result["feasible"]:
+        print(f"  Violated constraints: {result['violated_constraints']}")
+        for msg in result["violations"][:5]:
+            print(f"  - {msg}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as _frontieror_unexpected_error:
+        if not _frontieror_write_unexpected_rejection(
+            _frontieror_unexpected_error
+        ):
+            raise

tasks/engineer2012/gurobi_code.py

@@ -0,0 +1,904 @@
+#!/usr/bin/env python3
+"""
+Compact Arc-Flow MIP Formulation for the Maritime Inventory Routing Problem.
+
+Based on:
+  Engineer, Furman, Nemhauser, Savelsbergh, Song (2012),
+  "A Branch-Price-and-Cut Algorithm for Single-Product Maritime Inventory
+   Routing"
+
+Since the column-generation formulation in the paper cannot be directly solved
+by Gurobi (the set R_v of voyages is exponentially large), we implement a
+compact arc-flow formulation on a time-expanded network, as referenced in
+Song and Furman (2012).
+
+The formulation uses a commodity-flow approach for vessel inventory tracking:
+  - w[v,e]: continuous flow of product on arc e for vessel v
+  - This avoids the nonlinear constraint (10) from the paper and the need
+    for big-M linearization, yielding a much tighter LP relaxation.
+
+Usage:
+  python gurobi_code.py --instance_path path/to/instance.json \\
+                        --solution_path gurobi_solution.json \\
+                        --time_limit 3600
+"""
+
+import argparse
+import json
+import math
+import sys
+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
+# =============================================================================
+# Data Loading
+# =============================================================================
+
+def load_instance(path):
+    """Load instance data from a JSON file."""
+    with open(path, "r") as fh:
+        data = json.load(fh)
+    return data
+
+
+# =============================================================================
+# Helpers
+# =============================================================================
+
+def _node_str(node):
+    """Convert a node to a string suitable for constraint naming."""
+    if isinstance(node, tuple):
+        return f"{node[0]}_{node[1]}"
+    return str(node)
+
+
+# =============================================================================
+# Network Construction
+# =============================================================================
+
+def build_time_expanded_network(data):
+    """
+    Build a time-expanded network for each vessel.
+
+    For each vessel v, construct:
+      - Nodes: (j, t) for each port j and each time t in
+               [avail_start, avail_end], plus source 'src_v' and sink 'snk_v'
+      - Travel arcs: ((j1,t1), (j2,t2)) with t2 = t1 + travel_time(j1, j2)
+      - Demurrage arcs: ((j,t), (j,t+1)) for waiting at a port
+      - Source arcs: from src_v to supply port nodes at avail_start
+      - Sink arcs: from any port-time node to snk_v
+
+    INFERRED ASSUMPTION: Vessels start "at sea" and can reach any supply port
+    at their availability_start time.
+
+    Returns:
+      networks: dict keyed by vessel id
+      all_ports: list of port ids
+      port_type: dict port_id -> "supply" or "demand"
+      travel_time_dict: dict (p1,p2) -> int
+      draft_limit_dict: dict (v_id, p_id) -> float
+    """
+    T = data["planning_horizon"]
+    all_ports = []
+    port_type = {}
+    for sp in data["supply_ports"]:
+        all_ports.append(sp["port_id"])
+        port_type[sp["port_id"]] = "supply"
+    for dp in data["demand_ports"]:
+        all_ports.append(dp["port_id"])
+        port_type[dp["port_id"]] = "demand"
+
+    travel_time_dict = {}
+    for key, val in data["travel_times"].items():
+        p1, p2 = key.split("->")
+        travel_time_dict[(p1, p2)] = val
+
+    draft_limit_dict = {}
+    for key, val in data["draft_limits"].items():
+        v_id, p_id = key.split("->")
+        draft_limit_dict[(v_id, p_id)] = val
+
+    networks = {}
+
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        avail_start = vessel["availability_start"]
+        avail_end = vessel["availability_end"]
+        load_window_end = vessel["loading_window_end"]
+        cap = vessel["capacity"]
+
+        src_node = ("src", v_id)
+        snk_node = ("snk", v_id)
+
+        nodes = set()
+        arcs = []  # list of (tail, head, arc_type, cost)
+
+        # Port-time nodes
+        for j in all_ports:
+            for t in range(avail_start, avail_end + 1):
+                nodes.add((j, t))
+
+        # Travel arcs
+        for j1 in all_ports:
+            for j2 in all_ports:
+                if j1 == j2:
+                    continue
+                if (j1, j2) not in travel_time_dict:
+                    continue
+                tt = travel_time_dict[(j1, j2)]
+                arc_cost = vessel["transport_cost_per_day"] * tt
+                for t1 in range(avail_start, avail_end + 1):
+                    t2 = t1 + tt
+                    if t2 > avail_end:
+                        break
+                    arcs.append(((j1, t1), (j2, t2), "travel", arc_cost))
+
+        # Demurrage arcs
+        dem_cost = vessel["demurrage_cost_per_day"]
+        for j in all_ports:
+            for t in range(avail_start, avail_end):
+                arcs.append(((j, t), (j, t + 1), "demurrage", dem_cost))
+
+        # Source arcs: connect to supply ports at avail_start
+        # INFERRED ASSUMPTION: vessels can appear at any supply port at
+        # availability_start.  We also allow connections to demand ports
+        # for generality (the cost structure will discourage starting at
+        # demand ports without cargo).
+        for j in all_ports:
+            arcs.append((src_node, (j, avail_start), "source", 0.0))
+
+        # Sink arcs: from every port-time node
+        for j in all_ports:
+            for t in range(avail_start, avail_end + 1):
+                arcs.append(((j, t), snk_node, "sink", 0.0))
+
+        nodes.add(src_node)
+        nodes.add(snk_node)
+
+        # U_n: max product on vessel at node n
+        U_n = {}
+        for j in all_ports:
+            dl = draft_limit_dict.get((v_id, j), cap)
+            u = min(cap, dl)
+            for t in range(avail_start, avail_end + 1):
+                U_n[(j, t)] = u
+        U_n[src_node] = cap
+        # INFERRED ASSUMPTION: vessel may end the horizon with remaining
+        # inventory.  We do NOT force emptiness at avail_end.
+        U_n[snk_node] = cap
+
+        networks[v_id] = {
+            "nodes": nodes,
+            "arcs": arcs,
+            "src": src_node,
+            "snk": snk_node,
+            "U_n": U_n,
+            "capacity": cap,
+            "avail_start": avail_start,
+            "avail_end": avail_end,
+            "load_window_end": load_window_end,
+        }
+
+    return networks, all_ports, port_type, travel_time_dict, draft_limit_dict
+
+
+# =============================================================================
+# Preprocessing (Eqs. 16, 17)
+# =============================================================================
+
+def preprocess_bounds(data, networks, all_ports, port_type):
+    """
+    Tighten F_max at supply nodes (Eq. 16) and F_min at demand nodes (Eq. 17).
+
+    Sign convention:
+      Supply: f >= 0 (loading)   -> F_min >= 0, F_max >= 0
+      Demand: f <= 0 (discharge) -> F_min <= 0, F_max <= 0
+    """
+    port_data = {}
+    for sp in data["supply_ports"]:
+        port_data[sp["port_id"]] = sp
+    for dp in data["demand_ports"]:
+        port_data[dp["port_id"]] = dp
+
+    F_min_node = {}
+    F_max_node = {}
+
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        cap = vessel["capacity"]
+        net = networks[v_id]
+        a_s = net["avail_start"]
+        a_e = net["avail_end"]
+
+        for j in all_ports:
+            pd = port_data[j]
+            I0 = pd["initial_inventory"]
+
+            if port_type[j] == "supply":
+                prod = pd["production_rate"]
+                stor = pd["storage_capacity"]
+                Fj_min = pd["F_min"]
+                Fj_max = pd["F_max"]
+
+                for t in range(a_s, a_e + 1):
+                    sum_p_t = sum(prod[tp - 1] for tp in range(1, t + 1)
+                                 if tp - 1 < len(prod))
+                    sum_p_tm1 = sum(prod[tp - 1] for tp in range(1, t)
+                                   if tp - 1 < len(prod))
+                    Q_tm1 = stor[t - 2] if t >= 2 and t - 2 < len(stor) \
+                        else stor[0]
+                    b_t = prod[t - 1] if t - 1 < len(prod) else 0
+                    dl = net["U_n"].get((j, t), cap)
+
+                    excess = I0 + sum_p_tm1 - Q_tm1
+                    n_prior = math.ceil(max(0, excess) / Fj_max) if Fj_max > 0 else 0
+                    t4 = I0 + sum_p_t - n_prior * Fj_min
+
+                    t_max = min(Fj_max, dl, Q_tm1 + b_t, max(0, t4))
+                    t_max = max(t_max, 0)
+
+                    F_max_node[(v_id, j, t)] = t_max
+                    F_min_node[(v_id, j, t)] = Fj_min
+
+            else:  # demand
+                cons = pd["consumption_rate"]
+                stor = pd["storage_capacity"]
+                Fj_min_d = pd["F_min"]
+                Fj_max_d = pd["F_max"]
+
+                for t in range(a_s, a_e + 1):
+                    sum_c_t = sum(cons[tp - 1] for tp in range(1, t + 1)
+                                 if tp - 1 < len(cons))
+                    sum_c_tm1 = sum(cons[tp - 1] for tp in range(1, t)
+                                   if tp - 1 < len(cons))
+                    Q_t = stor[t - 1] if t - 1 < len(stor) else stor[-1]
+                    b_t = cons[t - 1] if t - 1 < len(cons) else 0
+                    dl = net["U_n"].get((j, t), cap)
+
+                    deficit = -I0 + sum_c_tm1
+                    n_prior = math.ceil(max(0, deficit) / Fj_max_d) \
+                        if Fj_max_d > 0 else 0
+                    avail_space = Q_t - I0 + sum_c_t - n_prior * Fj_min_d
+                    t4 = -max(0, avail_space)
+
+                    t_min = max(-Fj_max_d, -dl, -(Q_t + b_t), t4)
+                    t_min = min(t_min, 0)
+
+                    F_min_node[(v_id, j, t)] = t_min
+                    F_max_node[(v_id, j, t)] = -Fj_min_d
+
+    return F_min_node, F_max_node
+
+
+# =============================================================================
+# MIP Model
+# =============================================================================
+
+def build_model(data, networks, all_ports, port_type, F_min_node, F_max_node):
+    """
+    Build the compact arc-flow MIP using a commodity-flow formulation.
+
+    Variables:
+      x[v, arc_idx]  in {0,1}:  arc selection for vessel v
+      z[v, j, t]     in {0,1}:  load/discharge indicator
+      f[v, j, t]     continuous: quantity loaded (>0) or discharged (<0)
+      w[v, arc_idx]  >= 0:      product flow on arc for vessel v
+      I[j, t]        >= 0:      port inventory
+
+    The key insight: instead of tracking vessel inventory at nodes with big-M
+    constraints (which yields a very weak LP relaxation), we track the
+    commodity flow on each arc:
+      - w[v,e] represents the amount of product on vessel v traversing arc e
+      - Coupling: w[v,e] <= cap * x[v,e]
+      - Node balance: incoming_w + f[v,j,t] = outgoing_w  (product conservation)
+    This gives a tight LP relaxation and allows Gurobi to find solutions fast.
+    """
+    T = data["planning_horizon"]
+    model = gp.Model("MaritimeIRP")
+    model.setParam("Threads", 1)
+
+    port_data = {}
+    for sp in data["supply_ports"]:
+        port_data[sp["port_id"]] = sp
+    for dp in data["demand_ports"]:
+        port_data[dp["port_id"]] = dp
+
+    supply_ports = [sp["port_id"] for sp in data["supply_ports"]]
+    demand_ports = [dp["port_id"] for dp in data["demand_ports"]]
+
+    # -----------------------------------------------------------------
+    # Build arc index structures
+    # -----------------------------------------------------------------
+    out_arcs = {}   # (v_id, node) -> list of arc indices
+    in_arcs = {}    # (v_id, node) -> list of arc indices
+    arc_info = {}   # (v_id, arc_idx) -> (tail, head, atype, cost)
+
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        for idx, (tail, head, atype, cost) in enumerate(networks[v_id]["arcs"]):
+            arc_info[(v_id, idx)] = (tail, head, atype, cost)
+            out_arcs.setdefault((v_id, tail), []).append(idx)
+            in_arcs.setdefault((v_id, head), []).append(idx)
+
+    # =================================================================
+    # Variables
+    # =================================================================
+    print("  Creating variables...")
+
+    # x[v, arc_idx]: binary arc selection
+    x = {}
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        for idx in range(len(net["arcs"])):
+            _, _, atype, cost = arc_info[(v_id, idx)]
+            x[(v_id, idx)] = model.addVar(
+                vtype=GRB.BINARY, obj=cost, name=f"x_{v_id}_{idx}"
+            )
+
+    # w[v, arc_idx]: product flow on arc (continuous)
+    w = {}
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        cap = vessel["capacity"]
+        for idx in range(len(net["arcs"])):
+            w[(v_id, idx)] = model.addVar(
+                lb=0.0, ub=cap, vtype=GRB.CONTINUOUS,
+                name=f"w_{v_id}_{idx}"
+            )
+
+    # z[v, j, t]: binary load/discharge decision
+    z = {}
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        for j in all_ports:
+            for t in range(net["avail_start"], net["avail_end"] + 1):
+                z[(v_id, j, t)] = model.addVar(
+                    vtype=GRB.BINARY, name=f"z_{v_id}_{j}_{t}"
+                )
+
+    # f[v, j, t]: load/discharge quantity (continuous)
+    f = {}
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        for j in all_ports:
+            for t in range(net["avail_start"], net["avail_end"] + 1):
+                fmin = F_min_node.get((v_id, j, t), 0)
+                fmax = F_max_node.get((v_id, j, t), 0)
+                if port_type[j] == "supply":
+                    lb, ub = 0.0, max(fmax, 0.0)
+                    unit_cost = port_data[j]["unit_procurement_cost"]
+                else:
+                    lb, ub = min(fmin, 0.0), 0.0
+                    # f <= 0 at demand; unit_supply_revenue * f effectively
+                    # subtracts revenue from the objective
+                    unit_cost = port_data[j]["unit_supply_revenue"]
+
+                f[(v_id, j, t)] = model.addVar(
+                    lb=lb, ub=ub, vtype=GRB.CONTINUOUS,
+                    obj=unit_cost, name=f"f_{v_id}_{j}_{t}"
+                )
+
+    # I[j, t]: port inventory
+    I_var = {}
+    for j in all_ports:
+        pd = port_data[j]
+        stor = pd["storage_capacity"]
+        for t in range(1, T + 1):
+            Q_jt = stor[t - 1] if t - 1 < len(stor) else stor[-1]
+            I_var[(j, t)] = model.addVar(
+                lb=0.0, ub=Q_jt, vtype=GRB.CONTINUOUS,
+                name=f"I_{j}_{t}"
+            )
+
+    model.update()
+
+    # =================================================================
+    # Constraints
+    # =================================================================
+    print("  Adding constraints...")
+
+    # -----------------------------------------------------------------
+    # (C1) Flow conservation: path from source to sink for each vessel
+    # -----------------------------------------------------------------
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        src = net["src"]
+        snk = net["snk"]
+        for node in net["nodes"]:
+            o_list = out_arcs.get((v_id, node), [])
+            i_list = in_arcs.get((v_id, node), [])
+            out_sum = gp.quicksum(x[(v_id, i)] for i in o_list)
+            in_sum = gp.quicksum(x[(v_id, i)] for i in i_list)
+            if node == src:
+                rhs = 1
+            elif node == snk:
+                rhs = -1
+            else:
+                rhs = 0
+            model.addConstr(
+                out_sum - in_sum == rhs,
+                name=f"flow_{v_id}_{_node_str(node)}"
+            )
+
+    # -----------------------------------------------------------------
+    # (C2) Commodity flow coupling: w <= U_n * x
+    # The product flow w on arc (tail -> head) represents the cargo
+    # in transit.  This equals:
+    #   - EXIT inventory from tail (after loading at tail)
+    #   - ENTRY inventory at head (before loading at head)
+    # Draft limits must be enforced at BOTH endpoints:
+    #   w <= U_n(head) * x   (entry bound at destination)
+    #   w <= U_n(tail) * x   (exit bound at origin)
+    # Combined: w <= min(U_n(head), U_n(tail)) * x
+    # -----------------------------------------------------------------
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        cap = vessel["capacity"]
+        net = networks[v_id]
+        for idx in range(len(net["arcs"])):
+            tail, head, atype, _ = arc_info[(v_id, idx)]
+            if isinstance(head, tuple):
+                u_head = net["U_n"].get(head, cap)
+            else:
+                u_head = cap
+            if isinstance(tail, tuple):
+                u_tail = net["U_n"].get(tail, cap)
+            else:
+                u_tail = cap
+            u = min(u_head, u_tail)
+            model.addConstr(
+                w[(v_id, idx)] <= u * x[(v_id, idx)],
+                name=f"wcap_{v_id}_{idx}"
+            )
+
+    # -----------------------------------------------------------------
+    # (C3) Commodity flow conservation at each port-time node:
+    #   sum(incoming w) + f[v,j,t] = sum(outgoing w)
+    #
+    # For supply: f >= 0, so incoming_w + f = outgoing_w means vessel
+    #   picks up product (outgoing > incoming).
+    # For demand: f <= 0, so incoming_w + f = outgoing_w means vessel
+    #   drops off product (outgoing < incoming).
+    #
+    # At source node: initial_load + outgoing_w = 0 (if initial_load=0
+    #   this means vessel starts empty).
+    # At sink node: incoming_w = 0 is NOT enforced (vessel can end with
+    #   product).  We let the variable be free.
+    # -----------------------------------------------------------------
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        init_load = vessel["initial_load"]
+        src = net["src"]
+        snk = net["snk"]
+
+        # Source: outgoing product flow = initial_load
+        src_out = out_arcs.get((v_id, src), [])
+        model.addConstr(
+            gp.quicksum(w[(v_id, i)] for i in src_out) == init_load,
+            name=f"wbal_src_{v_id}"
+        )
+
+        # Port-time nodes
+        for j in all_ports:
+            for t in range(net["avail_start"], net["avail_end"] + 1):
+                node = (j, t)
+                i_list = in_arcs.get((v_id, node), [])
+                o_list = out_arcs.get((v_id, node), [])
+                in_w = gp.quicksum(w[(v_id, i)] for i in i_list)
+                out_w = gp.quicksum(w[(v_id, i)] for i in o_list)
+                model.addConstr(
+                    in_w + f[(v_id, j, t)] == out_w,
+                    name=f"wbal_{v_id}_{j}_{t}"
+                )
+
+        # Sink: no explicit constraint needed -- incoming w can be any
+        # non-negative value (product remaining on vessel).
+
+    # -----------------------------------------------------------------
+    # (C4) Load/discharge only if node is visited (Eq. 8):
+    #   z[v,j,t] <= sum of outgoing arcs from (j,t)
+    # -----------------------------------------------------------------
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        for j in all_ports:
+            for t in range(net["avail_start"], net["avail_end"] + 1):
+                node = (j, t)
+                o_list = out_arcs.get((v_id, node), [])
+                if not o_list:
+                    model.addConstr(z[(v_id, j, t)] == 0,
+                                    name=f"vis_{v_id}_{j}_{t}")
+                else:
+                    model.addConstr(
+                        z[(v_id, j, t)] <= gp.quicksum(
+                            x[(v_id, i)] for i in o_list),
+                        name=f"vis_{v_id}_{j}_{t}")
+
+    # -----------------------------------------------------------------
+    # (C5) Load/discharge quantity bounds (Eq. 9):
+    #   F_min * z <= f <= F_max * z
+    # -----------------------------------------------------------------
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        for j in all_ports:
+            for t in range(net["avail_start"], net["avail_end"] + 1):
+                fmin_val = F_min_node.get((v_id, j, t), 0)
+                fmax_val = F_max_node.get((v_id, j, t), 0)
+                model.addConstr(
+                    f[(v_id, j, t)] >= fmin_val * z[(v_id, j, t)],
+                    name=f"flo_{v_id}_{j}_{t}")
+                model.addConstr(
+                    f[(v_id, j, t)] <= fmax_val * z[(v_id, j, t)],
+                    name=f"fhi_{v_id}_{j}_{t}")
+
+    # -----------------------------------------------------------------
+    # (C6) Port inventory balance (Eqs. 1, 2):
+    #   Supply: I[j,t] = I[j,t-1] + b[j,t] - sum_v f[v,j,t]
+    #   Demand: I[j,t] = I[j,t-1] - b[j,t] - sum_v f[v,j,t]
+    # -----------------------------------------------------------------
+    for j in all_ports:
+        pd = port_data[j]
+        I0 = pd["initial_inventory"]
+
+        if port_type[j] == "supply":
+            rates = pd["production_rate"]
+            for t in range(1, T + 1):
+                b_jt = rates[t - 1] if t - 1 < len(rates) else 0
+                I_prev = I0 if t == 1 else I_var[(j, t - 1)]
+                total_f = gp.quicksum(
+                    f[(v["id"], j, t)]
+                    for v in data["vessels"]
+                    if (v["id"], j, t) in f
+                )
+                model.addConstr(
+                    I_var[(j, t)] == I_prev + b_jt - total_f,
+                    name=f"inv_{j}_{t}")
+        else:
+            rates = pd["consumption_rate"]
+            for t in range(1, T + 1):
+                b_jt = rates[t - 1] if t - 1 < len(rates) else 0
+                I_prev = I0 if t == 1 else I_var[(j, t - 1)]
+                total_f = gp.quicksum(
+                    f[(v["id"], j, t)]
+                    for v in data["vessels"]
+                    if (v["id"], j, t) in f
+                )
+                model.addConstr(
+                    I_var[(j, t)] == I_prev - b_jt - total_f,
+                    name=f"inv_{j}_{t}")
+
+    # Port storage bounds: already set via variable bounds on I_var.
+
+    # -----------------------------------------------------------------
+    # (C7) Loading window:
+    # INFERRED ASSUMPTION: The loading_window_end field indicates the
+    # latest time a vessel's FIRST loading can start.  We do NOT enforce
+    # a hard ban on loading at supply ports after loading_window_end,
+    # because doing so can make the problem infeasible when supply ports
+    # keep producing after all loading windows have closed.
+    # Instead, we treat the availability window [avail_start, avail_end]
+    # as the only hard time constraint on the vessel.  The loading
+    # window is interpreted as a soft scheduling preference encoded in
+    # the time-expanded network structure (vessels are unlikely to
+    # revisit supply ports after their initial transatlantic crossing
+    # due to travel time costs).
+    # -----------------------------------------------------------------
+
+    # -----------------------------------------------------------------
+    # (C8) Force load/discharge before relocating (symmetry breaking):
+    #   For a travel arc from (j,t), the vessel must have loaded/discharged
+    #   at port j at some point during its stay.  Simplified: either z=1
+    #   at (j,t), or the vessel arrived via a demurrage arc (was already
+    #   at j, so loaded earlier).
+    # -----------------------------------------------------------------
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        for idx, (tail, head, atype, cost) in enumerate(net["arcs"]):
+            if atype == "travel" and isinstance(tail, tuple):
+                j, t = tail
+                i_list = in_arcs.get((v_id, (j, t)), [])
+                dem_in = [ai for ai in i_list
+                          if arc_info[(v_id, ai)][2] == "demurrage"]
+                if dem_in:
+                    model.addConstr(
+                        x[(v_id, idx)] <= z[(v_id, j, t)] + gp.quicksum(
+                            x[(v_id, ai)] for ai in dem_in),
+                        name=f"fld_{v_id}_{idx}")
+                else:
+                    model.addConstr(
+                        x[(v_id, idx)] <= z[(v_id, j, t)],
+                        name=f"fld_{v_id}_{idx}")
+
+    model.update()
+    print(f"  Model: {model.NumVars} variables, {model.NumConstrs} constraints")
+
+    return model, x, w, z, f, I_var
+
+
+# =============================================================================
+# Solution Extraction
+# =============================================================================
+
+def extract_solution(model, data, networks, all_ports, port_type,
+                     x, w, z, f, I_var):
+    """Extract solution from the optimized Gurobi model."""
+    T = data["planning_horizon"]
+
+    solution = {
+        "objective_value": None,
+        "solver_status": None,
+        "mip_gap": None,
+        "solve_time": model.Runtime,
+        "vessel_routes": {},
+        "port_inventories": {},
+        "vessel_operations": {},
+    }
+
+    if model.SolCount == 0:
+        solution["solver_status"] = "no_feasible_solution"
+        return solution
+
+    solution["objective_value"] = model.ObjVal
+    solution["mip_gap"] = model.MIPGap
+    if model.Status == GRB.OPTIMAL:
+        solution["solver_status"] = "optimal"
+    elif model.Status == GRB.TIME_LIMIT:
+        solution["solver_status"] = "time_limit"
+    else:
+        solution["solver_status"] = f"status_{model.Status}"
+
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        route_arcs = []
+        operations = []
+
+        for idx, (tail, head, atype, cost) in enumerate(net["arcs"]):
+            if x[(v_id, idx)].X > 0.5:
+                w_val = w[(v_id, idx)].X
+                route_arcs.append({
+                    "tail": str(tail),
+                    "head": str(head),
+                    "type": atype,
+                    "cost": cost,
+                    "product_flow": round(w_val, 4),
+                })
+
+        for j in all_ports:
+            for t in range(net["avail_start"], net["avail_end"] + 1):
+                if (v_id, j, t) in z and z[(v_id, j, t)].X > 0.5:
+                    f_val = f[(v_id, j, t)].X
+                    operations.append({
+                        "port": j,
+                        "time": t,
+                        "quantity": round(f_val, 4),
+                        "type": ("load" if port_type[j] == "supply"
+                                 else "discharge"),
+                    })
+
+        solution["vessel_routes"][v_id] = route_arcs
+        solution["vessel_operations"][v_id] = operations
+
+    for j in all_ports:
+        inv = []
+        for t in range(1, T + 1):
+            if (j, t) in I_var:
+                inv.append({
+                    "time": t,
+                    "inventory": round(I_var[(j, t)].X, 4),
+                })
+        solution["port_inventories"][j] = inv
+
+    return solution
+
+
+def compute_cost_breakdown(model, data, networks, all_ports, port_type,
+                           x, f):
+    """Compute a detailed cost breakdown."""
+    if model.SolCount == 0:
+        return {}
+
+    port_data = {}
+    for sp in data["supply_ports"]:
+        port_data[sp["port_id"]] = sp
+    for dp in data["demand_ports"]:
+        port_data[dp["port_id"]] = dp
+
+    transport_cost = 0.0
+    demurrage_cost = 0.0
+    procurement_cost = 0.0
+    supply_revenue = 0.0
+
+    for vessel in data["vessels"]:
+        v_id = vessel["id"]
+        net = networks[v_id]
+        for idx, (tail, head, atype, cost) in enumerate(net["arcs"]):
+            if x[(v_id, idx)].X > 0.5:
+                if atype == "travel":
+                    transport_cost += cost
+                elif atype == "demurrage":
+                    demurrage_cost += cost
+
+        for j in all_ports:
+            for t in range(net["avail_start"], net["avail_end"] + 1):
+                if (v_id, j, t) in f:
+                    fv = f[(v_id, j, t)].X
+                    if abs(fv) > 1e-6:
+                        if port_type[j] == "supply":
+                            procurement_cost += (
+                                port_data[j]["unit_procurement_cost"] * fv)
+                        else:
+                            supply_revenue += (
+                                port_data[j]["unit_supply_revenue"] * (-fv))
+
+    return {
+        "transport_cost": round(transport_cost, 4),
+        "demurrage_cost": round(demurrage_cost, 4),
+        "procurement_cost": round(procurement_cost, 4),
+        "supply_revenue": round(supply_revenue, 4),
+        "total_cost": round(
+            transport_cost + demurrage_cost + procurement_cost
+            - supply_revenue, 4),
+    }
+
+
+# =============================================================================
+# Main
+# =============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compact arc-flow MIP for Maritime Inventory Routing "
+                    "(Engineer et al. 2012)")
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to instance JSON file.")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path to write solution JSON file.")
+    parser.add_argument("--time_limit", type=int, default=3600,
+                        help="Gurobi time limit in seconds (default 3600).")
+    parser.add_argument("--mip_gap", type=float, default=1e-4,
+                        help="Gurobi MIPGap tolerance (default 1e-4).")
+    parser.add_argument("--threads", type=int, default=1,
+                        help="Threads for Gurobi (default: 1).")
+    parser.add_argument("--verbose", action="store_true",
+                        help="Enable verbose Gurobi output.")
+    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)
+
+    print("=" * 70)
+    print("Maritime Inventory Routing Problem - Compact Arc-Flow MIP")
+    print("Based on Engineer et al. (2012)")
+    print("=" * 70)
+
+    # Load instance
+    print(f"\nLoading instance: {args.instance_path}")
+    data = load_instance(args.instance_path)
+    print(f"  Horizon={data['planning_horizon']}, "
+          f"vessels={data['num_vessels']}, "
+          f"supply={data['num_supply_ports']}, "
+          f"demand={data['num_demand_ports']}")
+
+    # Build networks
+    print("\nBuilding time-expanded networks...")
+    networks, all_ports, port_type, tt_dict, dl_dict = \
+        build_time_expanded_network(data)
+    for v_id, net in networks.items():
+        print(f"  {v_id}: {len(net['nodes'])} nodes, {len(net['arcs'])} arcs, "
+              f"avail=[{net['avail_start']},{net['avail_end']}], "
+              f"load_end={net['load_window_end']}")
+
+    # Preprocess
+    print("\nPreprocessing bounds (Eqs. 16, 17)...")
+    F_min_node, F_max_node = preprocess_bounds(
+        data, networks, all_ports, port_type)
+
+    # Build model
+    print("\nBuilding MIP model...")
+    model, x, w, z, f, I_var = build_model(
+        data, networks, all_ports, port_type, F_min_node, F_max_node)
+
+    # Gurobi parameters
+    model.setParam("TimeLimit", args.time_limit)
+    if args.mip_gap > 0:
+        model.setParam("MIPGap", args.mip_gap)
+    if args.threads > 0:
+        model.setParam("Threads", args.threads)
+    if not args.verbose:
+        model.setParam("OutputFlag", 1)
+    # Find any feasible incumbent quickly — maritime inventory routing has a
+    # tight LP relaxation and gurobi can spend the full budget proving infeas/
+    # closing gap without producing an incumbent. MIPFocus=1 + NoRelHeurTime
+    # bias the search toward feasibility.
+    model.setParam("MIPFocus", 1)
+    model.setParam("NoRelHeurTime", min(60.0, args.time_limit * 0.05))
+
+    # Optimize
+    print("\nOptimizing...")
+    print("=" * 70)
+    t0 = time.time()
+    model.optimize()
+    solve_time = time.time() - t0
+    print("=" * 70)
+
+    # Report
+    print(f"\nSolve time: {solve_time:.2f}s")
+    print(f"Gurobi status: {model.Status}")
+
+    if model.SolCount > 0:
+        print(f"Objective value: {model.ObjVal:.4f}")
+        print(f"MIP gap: {model.MIPGap:.6f}")
+        if model.Status == GRB.OPTIMAL:
+            print("Solution is OPTIMAL.")
+        else:
+            print("Feasible solution found (not proven optimal).")
+
+        breakdown = compute_cost_breakdown(
+            model, data, networks, all_ports, port_type, x, f)
+        print("\nCost Breakdown:")
+        for k, v in breakdown.items():
+            print(f"  {k}: {v}")
+
+        print("\nVessel Operations:")
+        for vessel in data["vessels"]:
+            v_id = vessel["id"]
+            net = networks[v_id]
+            ops = []
+            for j in all_ports:
+                for t in range(net["avail_start"], net["avail_end"] + 1):
+                    if (v_id, j, t) in z and z[(v_id, j, t)].X > 0.5:
+                        fv = f[(v_id, j, t)].X
+                        ptype = "load" if port_type[j] == "supply" else "disch"
+                        ops.append((t, j, ptype, fv))
+            if ops:
+                ops.sort()
+                print(f"  {v_id}:")
+                for (t, j, pt, fv) in ops:
+                    print(f"    t={t:3d} {pt:6s} at {j}: {fv:+.2f}")
+            else:
+                print(f"  {v_id}: idle")
+    else:
+        print("No feasible solution found.")
+
+    # Save solution
+    solution = extract_solution(
+        model, data, networks, all_ports, port_type, x, w, z, f, I_var)
+    solution["solve_time"] = round(solve_time, 2)
+    solution["instance_path"] = args.instance_path
+    if model.SolCount > 0:
+        solution["cost_breakdown"] = compute_cost_breakdown(
+            model, data, networks, all_ports, port_type, x, f)
+
+    print(f"\nSaving solution to: {args.solution_path}")
+    with open(args.solution_path, "w") as fout:
+        solution["runtime"] = time.time() - _GUROBI_CODE_START_TIME
+        json.dump(solution, fout, indent=2)
+
+    print("Done.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/engineer2012/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/engineer2012/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/engineer2012/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/engineer2012/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/engineer2012/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/engineer2012/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/engineer2012/gurobi_feasi_result/tiny_feasi_result_2.json

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

tasks/engineer2012/gurobi_solution/large_solution_1.json

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

tasks/engineer2012/gurobi_solution/large_solution_2.json

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

tasks/engineer2012/gurobi_solution/large_solution_3.json

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

tasks/engineer2012/gurobi_solution/large_solution_4.json

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

tasks/engineer2012/gurobi_solution/large_solution_5.json

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

tasks/engineer2012/gurobi_solution/tiny_solution.json

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