Fix delage2022 closed-ended and knife-dependent variants

delage2022/feasibility_check.py

@@ -0,0 +1,530 @@
+#!/usr/bin/env python3
+"""
+Feasibility checker for the three paper-supported CSCP variants.
+
+Checks all hard constraints from the mathematical formulation (equations 16-23)
+in Pérez Martínez, Adulyasak, and Jans (2022).
+
+Constraints are numbered 1-8 counting top to bottom from the formulation:
+  Constraint 1 (eq 16): sum_{i in T} l_i * a_{ij} <= L * s_j,  forall j in P
+  Constraint 2 (eq 17): z_j <= M * s_j,  forall j in P
+  Constraint 3 (eq 18): q_{ij} = a_{ij} * z_j,  forall i in T, j in P
+  Constraint 4 (eq 19): sum_j q_{ij} + x_i >= d_i,  forall i in T
+  Constraint 5 (eq 20): sum_j z_j >= sum_i x_i
+  Constraint 6 (eq 21): z_{j-1} >= z_j,  forall j in P, j > 1
+  Constraint 7 (eq 22): s_j in {0,1}, a_{ij} in Z_+,  forall i,j
+  Constraint 8 (eq 23): x_i >= 0, z_j in Z_+, q_{ij} >= 0,  forall i,j
+  Constraint 9 (eq 15): objective consistency -- the reported objective_value
+                        must equal the recomputed total time
+                        C_s * sum_j s_j + C_r * sum_j z_j, plus the
+                        knife-dependent setup term when applicable.
+
+Constraint 9 is a Tier-C anti-gaming check: the eval pipeline otherwise trusts
+the program's self-reported objective_value. Every variable the objective
+(eq 15) depends on -- the pattern setup flags s_j and the repetition counts
+z_j -- is present in the solution, so a full recompute is possible and exact.
+"""
+
+import argparse
+import json
+import math
+
+# FRONTIEROR_RELEASE_CONTRACT_V2
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('extra_pieces', 'objective_value', 'patterns', 'production_quantities')
+_FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ()
+_FRONTIEROR_DERIVED_FIELD_RULES = ()
+_FRONTIEROR_CONDITIONAL_FIELD_RULES = ()
+
+
+def _frontieror_validate_solution_contract(solution):
+    """Return a structured rejection when the public solution contract is absent."""
+    violations = []
+    if not isinstance(solution, dict):
+        violations.append("solution must be a JSON object")
+    else:
+        missing = [
+            field
+            for field in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS
+            if field not in solution or solution[field] is None
+        ]
+        if missing:
+            violations.append(
+                "missing required solution field(s): " + ", ".join(missing)
+            )
+
+        for discriminator, expected_value, fields in _FRONTIEROR_CONDITIONAL_FIELD_RULES:
+            if solution.get(discriminator) != expected_value:
+                continue
+            conditional_missing = [
+                field
+                for field in fields
+                if field not in solution or solution[field] is None
+            ]
+            if conditional_missing:
+                violations.append(
+                    "missing conditionally required solution field(s): "
+                    + ", ".join(conditional_missing)
+                )
+
+        empty = [
+            field
+            for field in _FRONTIEROR_NONEMPTY_SOLUTION_FIELDS
+            if field in solution and solution[field] in (None, [], {})
+        ]
+        if empty:
+            violations.append(
+                "empty required decision witness field(s): " + ", ".join(empty)
+            )
+
+        for target, operation, source, source_key in _FRONTIEROR_DERIVED_FIELD_RULES:
+            try:
+                reported = float(solution[target])
+                if operation == "length":
+                    expected = float(len(solution[source]))
+                elif operation == "mapping_value":
+                    expected = float(solution[source][source_key])
+                else:
+                    raise ValueError("unknown derived-field operation")
+            except (KeyError, TypeError, ValueError, OverflowError):
+                violations.append(
+                    f"cannot derive {target} from decision witness field {source}"
+                )
+                continue
+            if (
+                reported != reported
+                or expected != expected
+                or reported in (float("inf"), float("-inf"))
+                or expected in (float("inf"), float("-inf"))
+                or abs(reported - expected) > 1e-6
+            ):
+                violations.append(
+                    f"{target}={reported} does not match the decision-derived "
+                    f"value {expected}"
+                )
+
+        if "objective_value" in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS:
+            objective = solution.get("objective_value")
+            if (
+                isinstance(objective, bool)
+                or not isinstance(objective, (int, float))
+                or objective != objective
+                or objective in (float("inf"), float("-inf"))
+            ):
+                violations.append("objective_value must be a finite JSON number")
+
+    if not violations:
+        return None
+    return {
+        "feasible": False,
+        "violated_constraints": ["solution_schema"],
+        "violations": violations,
+        "violation_magnitudes": [],
+    }
+
+
+def _frontieror_write_unexpected_rejection(error):
+    """Turn malformed candidate/checker exceptions into a normal rejection."""
+    import json as _frontieror_json
+    import sys as _frontieror_sys
+
+    result_path = None
+    for index, argument in enumerate(_frontieror_sys.argv):
+        if argument == "--result_path" and index + 1 < len(_frontieror_sys.argv):
+            result_path = _frontieror_sys.argv[index + 1]
+            break
+        if argument.startswith("--result_path="):
+            result_path = argument.split("=", 1)[1]
+            break
+    if not result_path:
+        return False
+    try:
+        with open(result_path, "w") as result_handle:
+            _frontieror_json.dump(
+                {
+                    "feasible": False,
+                    "violated_constraints": ["malformed_solution"],
+                    "violations": [
+                        "checker rejected malformed candidate: "
+                        + type(error).__name__
+                        + ": "
+                        + str(error)[:500]
+                    ],
+                    "violation_magnitudes": [],
+                },
+                result_handle,
+                indent=2,
+            )
+    except Exception:
+        return False
+    return True
+
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Feasibility checker for CSCP variants"
+    )
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to the JSON instance file")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path to the JSON solution file")
+    parser.add_argument("--result_path", type=str, required=True,
+                        help="Path to write the feasibility result JSON")
+    args = parser.parse_args()
+
+    with open(args.instance_path, "r") as f:
+        instance = json.load(f)
+    with open(args.solution_path, "r") as f:
+        solution = json.load(f)
+        _frontieror_contract_result = _frontieror_validate_solution_contract(solution)
+        if _frontieror_contract_result is not None:
+            with open(args.result_path, "w") as _frontieror_result_handle:
+                json.dump(
+                    _frontieror_contract_result,
+                    _frontieror_result_handle,
+                    indent=2,
+                )
+            return
+
+    result = check_feasibility(instance, solution)
+
+    with open(args.result_path, "w") as f:
+        json.dump(result, f, indent=2)
+
+    print(f"Feasibility result written to {args.result_path}")
+    print(f"Feasible: {result['feasible']}")
+    if not result["feasible"]:
+        print(f"Violated constraints: {result['violated_constraints']}")
+        for v in result["violations"]:
+            print(f"  - {v}")
+
+
+def check_feasibility(instance, solution):
+    tol = 1e-5
+    eps = 1e-5
+
+    # --- Parse instance data ---
+    products = instance["products"]
+    num_products = instance["num_products"]
+    num_patterns = instance["num_patterns"]
+    L = instance["machine_length"]
+    M_val = instance["M"]
+    problem_type = instance.get("problem_type", "open_ended_cscp")
+    supported_types = {
+        "open_ended_cscp",
+        "closed_ended_cscp",
+        "cscp_with_knife_dependent_setups",
+    }
+    if problem_type not in supported_types:
+        raise ValueError(f"Unsupported problem_type: {problem_type}")
+    is_closed_ended = problem_type == "closed_ended_cscp"
+    is_knife_dependent = problem_type == "cscp_with_knife_dependent_setups"
+
+    T = list(range(num_products))  # 0-indexed
+    P = list(range(num_patterns))  # 0-indexed
+
+    d = {i: products[i]["demand"] for i in T}
+    l = {i: products[i]["length"] for i in T}
+    product_ids = {i: products[i]["id"] for i in T}
+    # Reverse map: product_id (int) -> 0-indexed
+    id_to_idx = {products[i]["id"]: i for i in T}
+
+    # --- Parse solution ---
+    patterns = solution["patterns"]
+    extra_pieces = solution["extra_pieces"]
+
+    # s_j: whether pattern j is used
+    s = {}
+    # z_j: repetitions of pattern j
+    z = {}
+    # a[i][j]: pieces of product i in pattern j
+    a = {}
+    knife_counts = {}
+    for j in P:
+        pdata = patterns[str(j)]
+        s[j] = 1 if pdata["used"] else 0
+        z[j] = pdata["repetitions"]
+        for i in T:
+            pid_str = str(product_ids[i])
+            a[(i, j)] = pdata["pieces"].get(pid_str, 0)
+        if is_knife_dependent:
+            if "knife_count" not in pdata:
+                raise ValueError(
+                    f"pattern {j} missing knife_count for knife-dependent instance"
+                )
+            knife_counts[j] = pdata["knife_count"]
+
+    # x_i: extra pieces
+    x = {}
+    for i in T:
+        pid_str = str(product_ids[i])
+        x[i] = extra_pieces.get(pid_str, 0.0)
+
+    # q_{ij} = a_{ij} * z_j (computed from solution, this IS the production quantity)
+    q = {}
+    for i in T:
+        for j in P:
+            q[(i, j)] = a[(i, j)] * z[j]
+
+    # If the solution provides explicit production_quantities, use those for
+    # checking constraint 3 (eq 18) mismatch
+    q_reported = None
+    if "production_quantities" in solution:
+        q_reported = {}
+        for i in T:
+            for j in P:
+                key = f"product_{product_ids[i]}_pattern_{j}"
+                q_reported[(i, j)] = solution["production_quantities"].get(key, 0.0)
+
+    # --- Check constraints ---
+    violated_constraints = set()
+    violations = []
+    violation_magnitudes = []
+
+    def record_violation(constraint_idx, msg, lhs, rhs, violation_amount):
+        violated_constraints.add(constraint_idx)
+        violations.append(msg)
+        normalizer = max(abs(rhs), eps)
+        violation_magnitudes.append({
+            "constraint": constraint_idx,
+            "lhs": float(lhs),
+            "rhs": float(rhs),
+            "raw_excess": float(violation_amount),
+            "normalizer": float(normalizer),
+            "ratio": float(violation_amount / normalizer)
+        })
+
+    # ---- Constraint 1 (eq 16): sum_{i in T} l_i * a_{ij} <= L * s_j ----
+    for j in P:
+        lhs = sum(l[i] * a[(i, j)] for i in T)
+        rhs = L * s[j]
+        violation_amount = lhs - rhs
+        if violation_amount > tol:
+            record_violation(
+                1,
+                f"Constraint 1 (eq 16) violated for pattern {j}: "
+                f"sum of piece lengths = {lhs}, but L*s_j = {rhs}",
+                lhs, rhs, violation_amount
+            )
+
+    # ---- Constraint 2 (eq 17): z_j <= M * s_j ----
+    for j in P:
+        lhs = z[j]
+        rhs = M_val * s[j]
+        violation_amount = lhs - rhs
+        if violation_amount > tol:
+            record_violation(
+                2,
+                f"Constraint 2 (eq 17) violated for pattern {j}: "
+                f"z_j = {lhs}, but M*s_j = {rhs}",
+                lhs, rhs, violation_amount
+            )
+
+    # ---- Constraint 3 (eq 18): q_{ij} = a_{ij} * z_j ----
+    # If solution reports explicit q values, check they match a_{ij}*z_j
+    if q_reported is not None:
+        for i in T:
+            for j in P:
+                lhs = q_reported[(i, j)]
+                rhs = a[(i, j)] * z[j]
+                violation_amount = abs(lhs - rhs)
+                if violation_amount > tol:
+                    record_violation(
+                        3,
+                        f"Constraint 3 (eq 18) violated for product {product_ids[i]}, "
+                        f"pattern {j}: q_reported = {lhs}, a*z = {rhs}",
+                        lhs, rhs, violation_amount
+                    )
+
+    # ---- Constraint 4 (eq 19): sum_j q_{ij} + x_i >= d_i ----
+    for i in T:
+        total_q = sum(q[(i, j)] for j in P)
+        lhs = total_q + x[i]
+        rhs = d[i]
+        violation_amount = rhs - lhs  # >= constraint: RHS exceeds LHS
+        if violation_amount > tol:
+            record_violation(
+                4,
+                f"Constraint 4 (eq 19) violated for product {product_ids[i]}: "
+                f"total production + extra = {lhs}, demand = {rhs}",
+                lhs, rhs, violation_amount
+            )
+
+    # ---- Constraint 5 (eq 20): sum_j z_j >= sum_i x_i ----
+    lhs_5 = sum(z[j] for j in P)
+    rhs_5 = sum(x[i] for i in T)
+    violation_amount_5 = rhs_5 - lhs_5  # >= constraint
+    if violation_amount_5 > tol:
+        record_violation(
+            5,
+            f"Constraint 5 (eq 20) violated: "
+            f"sum(z_j) = {lhs_5}, sum(x_i) = {rhs_5}",
+            lhs_5, rhs_5, violation_amount_5
+        )
+
+    # ---- Constraint 6 (eq 21): z_{j-1} >= z_j, for j > 0 ----
+    for j in P:
+        if j > 0:
+            lhs = z[j - 1]
+            rhs = z[j]
+            violation_amount = rhs - lhs  # >= constraint: z_{j-1} >= z_j
+            if violation_amount > tol:
+                record_violation(
+                    6,
+                    f"Constraint 6 (eq 21) violated: "
+                    f"z_{j-1} = {lhs} < z_{j} = {rhs}",
+                    lhs, rhs, violation_amount
+                )
+
+    # ---- Constraint 7 (eq 22): s_j in {0,1}, a_{ij} in Z_+ ----
+    for j in P:
+        val = s[j]
+        if val not in (0, 1):
+            record_violation(
+                7,
+                f"Constraint 7 (eq 22) violated: s_{j} = {val} not in {{0,1}}",
+                val, 0, 1.0
+            )
+        for i in T:
+            val_a = a[(i, j)]
+            if not isinstance(val_a, int) or val_a < 0:
+                if isinstance(val_a, float) and abs(val_a - round(val_a)) < tol and val_a >= -tol:
+                    pass  # close enough to non-negative integer
+                else:
+                    violation_amount = abs(val_a - round(val_a)) if val_a >= 0 else abs(val_a)
+                    record_violation(
+                        7,
+                        f"Constraint 7 (eq 22) violated: a_{product_ids[i]},{j} = {val_a} "
+                        f"not a non-negative integer",
+                        val_a, round(max(val_a, 0)), violation_amount
+                    )
+
+    # ---- Constraint 8 (eq 23): x_i >= 0, z_j in Z_+, q_{ij} >= 0 ----
+    for i in T:
+        if x[i] < -tol:
+            record_violation(
+                8,
+                f"Constraint 8 (eq 23) violated: x_{product_ids[i]} = {x[i]} < 0",
+                x[i], 0.0, abs(x[i])
+            )
+
+        if is_closed_ended and abs(x[i]) > tol:
+            record_violation(
+                10,
+                f"Closed-ended constraint violated: x_{product_ids[i]} = "
+                f"{x[i]}, expected 0",
+                x[i], 0.0, abs(x[i])
+            )
+
+    for j in P:
+        val_z = z[j]
+        if isinstance(val_z, float):
+            if abs(val_z - round(val_z)) > tol or val_z < -tol:
+                violation_amount = abs(val_z - round(val_z)) if val_z >= 0 else abs(val_z)
+                record_violation(
+                    8,
+                    f"Constraint 8 (eq 23) violated: z_{j} = {val_z} "
+                    f"not a non-negative integer",
+                    val_z, round(max(val_z, 0)), violation_amount
+                )
+        elif isinstance(val_z, int):
+            if val_z < 0:
+                record_violation(
+                    8,
+                    f"Constraint 8 (eq 23) violated: z_{j} = {val_z} < 0",
+                    val_z, 0, abs(val_z)
+                )
+
+    for i in T:
+        for j in P:
+            if q[(i, j)] < -tol:
+                record_violation(
+                    8,
+                    f"Constraint 8 (eq 23) violated: q_{product_ids[i]},{j} = {q[(i,j)]} < 0",
+                    q[(i, j)], 0.0, abs(q[(i, j)])
+                )
+
+    # ---- Constraint 11: knife_count_j equals pieces cut per pass ----
+    if is_knife_dependent:
+        for j in P:
+            reported_knives = knife_counts[j]
+            expected_knives = sum(a[(i, j)] for i in T)
+            valid_numeric = (
+                not isinstance(reported_knives, bool)
+                and isinstance(reported_knives, (int, float))
+                and math.isfinite(float(reported_knives))
+            )
+            if not valid_numeric:
+                record_violation(
+                    11,
+                    f"Knife-count constraint violated for pattern {j}: "
+                    f"reported {reported_knives!r}, expected a finite integer",
+                    0.0, expected_knives, abs(expected_knives)
+                )
+            elif (
+                isinstance(reported_knives, bool)
+                or reported_knives < -tol
+                or abs(reported_knives - round(reported_knives)) > tol
+                or abs(reported_knives - expected_knives) > tol
+            ):
+                record_violation(
+                    11,
+                    f"Knife-count constraint violated for pattern {j}: "
+                    f"reported {reported_knives}, expected {expected_knives}",
+                    reported_knives, expected_knives,
+                    abs(reported_knives - expected_knives)
+                )
+
+    # ---- Constraint 9 (eq 15): objective consistency ----
+    # Tier-C anti-gaming check. The objective (eq 15) is
+    #   C_s * sum_j s_j + C_r * sum_j z_j
+    # and every term -- the setup flags s_j and repetition counts z_j -- is
+    # present in the solution, so this is an exact full recompute. Reject the
+    # solution when the reported objective_value disagrees.
+    reported_obj = solution.get("objective_value")
+    if reported_obj is not None:
+        try:
+            reported = float(reported_obj)
+        except (TypeError, ValueError):
+            reported = None
+        if reported is not None:
+            C_s = instance["cost_setup_pattern"]
+            C_r = instance["cost_repetition"]
+            true_obj = float(C_s * sum(s[j] for j in P)
+                             + C_r * sum(z[j] for j in P))
+            if is_knife_dependent:
+                C_k = instance["cost_knife_setup"]
+                true_obj += float(C_k * sum(knife_counts[j] for j in P))
+            abs_diff = abs(reported - true_obj)
+            # The objective is an integer count (C_s, C_r, s_j, z_j all
+            # integral); a 0.5 absolute floor fires on any integer mismatch,
+            # with a tiny relative term for large-magnitude safety.
+            obj_tol = max(0.5, 1e-6 * abs(true_obj))
+            if abs_diff > obj_tol:
+                record_violation(
+                    9,
+                    f"Constraint 9 (eq 15) violated: reported objective_value "
+                    f"= {reported} differs from recomputed "
+                    f"variant-specific objective = {true_obj} "
+                    f"(|diff| = {abs_diff:.6g}, tol = {obj_tol:.6g})",
+                    reported, true_obj, abs_diff
+                )
+
+    # --- Build output ---
+    feasible = len(violated_constraints) == 0
+    return {
+        "feasible": feasible,
+        "violated_constraints": sorted(violated_constraints),
+        "violations": violations,
+        "violation_magnitudes": violation_magnitudes
+    }
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as _frontieror_unexpected_error:
+        if not _frontieror_write_unexpected_rejection(
+            _frontieror_unexpected_error
+        ):
+            raise

delage2022/gurobi_code.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+Gurobi-based MIP solver for the three paper-supported CSCP variants.
+
+Source: Pérez Martínez, Adulyasak, and Jans (2022),
+"Logic-Based Benders Decomposition for Integrated Process Configuration
+and Production Planning Problems," INFORMS Journal on Computing, 34(4), pp. 2177-2191.
+
+The OP has a nonlinear constraint q_{ij} = a_{ij} * z_j (eq. 18).
+This is linearized via:
+  1. Binary substitution (eq. 24): a_{ij} = sum_{k in K_i} b_k * w_{ijk},
+     where b_k = 2^{k-1}, K_i = {1, ..., n_i}, n_i = ceil(log2(N_i+1)).
+  2. McCormick linearization: u_{ijk} = w_{ijk} * z_j (binary x integer):
+       u_{ijk} >= 0
+       u_{ijk} <= M * w_{ijk}
+       u_{ijk} <= z_j
+       u_{ijk} >= z_j - M * (1 - w_{ijk})
+  Then q_{ij} = sum_{k in K_i} b_k * u_{ijk}  (exact, linear).
+"""
+
+import argparse
+import json
+import math
+
+import gurobipy as gp
+from gurobipy import GRB
+import os as _os, sys as _sys
+import time
+# Walk up from this file's directory to find repo root (containing scripts/).
+_GUROBI_CODE_START_TIME = time.time()
+_repo = _os.path.dirname(_os.path.abspath(__file__))
+while _repo != _os.path.dirname(_repo) and not _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _repo = _os.path.dirname(_repo)
+if _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _sys.path.insert(0, _repo)
+try:
+    from scripts.utils.gurobi_log_helper import install_gurobi_logger
+except ImportError:
+    def install_gurobi_logger(log_path):  # no-op fallback when scripts/ unavailable
+        pass
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Solve Open-Ended CSCP using Gurobi (linearized MIP)"
+    )
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to the JSON instance file")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path to write the solution JSON file")
+    parser.add_argument("--time_limit", type=int, required=True,
+                        help="Maximum solver runtime in seconds")
+    parser.add_argument("--log_path", type=str, default=None, help="Path to log incumbent solutions")
+    args = parser.parse_args()
+    install_gurobi_logger(args.log_path)
+
+    # ------------------------------------------------------------------
+    # Load instance
+    # ------------------------------------------------------------------
+    with open(args.instance_path, "r") as f:
+        instance = json.load(f)
+
+    products = instance["products"]
+    num_products = instance["num_products"]
+    num_patterns = instance["num_patterns"]
+    L = instance["machine_length"]
+    C_s = instance["cost_setup_pattern"]
+    C_r = instance["cost_repetition"]
+    M = instance["M"]  # M = max_{i in T} {d_i}  (large number, eq. defined in paper)
+    problem_type = instance.get("problem_type", "open_ended_cscp")
+    supported_types = {
+        "open_ended_cscp",
+        "closed_ended_cscp",
+        "cscp_with_knife_dependent_setups",
+    }
+    if problem_type not in supported_types:
+        raise ValueError(f"Unsupported problem_type: {problem_type}")
+    is_closed_ended = problem_type == "closed_ended_cscp"
+    is_knife_dependent = problem_type == "cscp_with_knife_dependent_setups"
+    C_k = instance.get("cost_knife_setup", 0)
+    if is_closed_ended and not instance.get("x_i_forced_zero", False):
+        raise ValueError("closed_ended_cscp requires x_i_forced_zero=true")
+    if is_knife_dependent and C_k < 0:
+        raise ValueError("cost_knife_setup must be nonnegative")
+
+    T = list(range(num_products))   # 0-indexed product indices
+    P = list(range(num_patterns))   # 0-indexed pattern indices
+
+    d = [products[i]["demand"] for i in T]
+    l = [products[i]["length"] for i in T]
+    N_i = [products[i]["N_i"] for i in T]  # floor(L / l_i)
+
+    # ------------------------------------------------------------------
+    # Binary substitution parameters (eq. 24)
+    # n_i = minimum number of bits to represent N_i
+    # K_i = {1, ..., n_i}  (1-indexed)
+    # b_k = 2^{k-1}
+    # ------------------------------------------------------------------
+    def get_n_bits(Ni):
+        if Ni == 0:
+            return 1
+        return max(1, math.ceil(math.log2(Ni + 1)))
+
+    n_bits = [get_n_bits(N_i[i]) for i in T]
+    K_i = [list(range(1, n_bits[i] + 1)) for i in T]  # 1-indexed
+
+    def bk(k):
+        return 2 ** (k - 1)  # b_k = 2^{k-1}
+
+    # ------------------------------------------------------------------
+    # Build Gurobi model
+    # ------------------------------------------------------------------
+    model = gp.Model(f"CSCP_Linearized_{problem_type}")
+    model.setParam("Seed", 0)
+    model.setParam("MIPGap", 1e-4)
+    model.setParam("NumericFocus", 0)
+    model.setParam("Threads", 1)
+    model.setParam("TimeLimit", args.time_limit)
+    model.setParam("OutputFlag", 1)
+
+    # --- Variables ---
+
+    # s_j in {0,1}: 1 if pattern j is used (eq. 22)
+    s = model.addVars(P, vtype=GRB.BINARY, name="s")
+
+    # w_{ijk} in {0,1}: bit k of a_{ij} (binary substitution, eq. 24)
+    w = {}
+    for i in T:
+        for j in P:
+            for k in K_i[i]:
+                w[i, j, k] = model.addVar(vtype=GRB.BINARY, name=f"w_{i}_{j}_{k}")
+
+    # z_j in Z_+: number of repetitions of pattern j (eq. 23)
+    z = model.addVars(P, vtype=GRB.INTEGER, lb=0, ub=M, name="z")
+
+    # x_i >= 0: extra pieces of product i.
+    # INFERRED ASSUMPTION: declared continuous (x_i >= 0 per eq. 23, in R_+ component
+    # of y-vector). Physically integer, but relaxed here for faithfulness to OP form.
+    x = model.addVars(T, lb=0.0, ub=0.0 if is_closed_ended else GRB.INFINITY, name="x")
+
+    # n_j: number of knives in pattern j for the knife-dependent variant.
+    knife_count = None
+    if is_knife_dependent:
+        knife_count = model.addVars(P, lb=0.0, name="knife_count")
+
+    # u_{ijk} = w_{ijk} * z_j  (McCormick linearization auxiliary)
+    u = {}
+    for i in T:
+        for j in P:
+            for k in K_i[i]:
+                u[i, j, k] = model.addVar(lb=0.0, ub=float(M), name=f"u_{i}_{j}_{k}")
+
+    # q_{ij} >= 0: production quantity (eq. 23), defined by linearization below
+    q = {}
+    for i in T:
+        for j in P:
+            q[i, j] = model.addVar(lb=0.0, name=f"q_{i}_{j}")
+
+    # --- Objective (eq. 15) ---
+    objective = (
+        C_s * gp.quicksum(s[j] for j in P)
+        + C_r * gp.quicksum(z[j] for j in P)
+    )
+    if is_knife_dependent:
+        objective += C_k * gp.quicksum(knife_count[j] for j in P)
+    model.setObjective(objective, GRB.MINIMIZE)
+
+    # --- Constraints ---
+
+    # (16)/(25) Configuration constraints:
+    # sum_{i in T} l_i * sum_{k in K_i} b_k * w_{ijk} <= L * s_j  for all j in P
+    for j in P:
+        model.addConstr(
+            gp.quicksum(
+                l[i] * gp.quicksum(bk(k) * w[i, j, k] for k in K_i[i])
+                for i in T
+            ) <= L * s[j],
+            name=f"config_{j}"
+        )
+
+    # (17) Linking constraints: z_j <= M * s_j  for all j in P
+    for j in P:
+        model.addConstr(z[j] <= M * s[j], name=f"link_{j}")
+
+    # Online supplement, Section 1.1.2: the knife setup is proportional to
+    # the number of pieces cut simultaneously by each used pattern.
+    if is_knife_dependent:
+        for j in P:
+            model.addConstr(
+                knife_count[j]
+                >= gp.quicksum(
+                    bk(k) * w[i, j, k] for i in T for k in K_i[i]
+                ) + M * (s[j] - 1),
+                name=f"knife_count_{j}",
+            )
+
+    # McCormick linearization of u_{ijk} = w_{ijk} * z_j
+    # (w_{ijk} binary, z_j integer with upper bound M)
+    for i in T:
+        for j in P:
+            for k in K_i[i]:
+                model.addConstr(u[i, j, k] <= M * w[i, j, k],         name=f"mck_a_{i}_{j}_{k}")
+                model.addConstr(u[i, j, k] <= z[j],                    name=f"mck_b_{i}_{j}_{k}")
+                model.addConstr(u[i, j, k] >= z[j] - M * (1 - w[i, j, k]), name=f"mck_c_{i}_{j}_{k}")
+
+    # q_{ij} = sum_{k in K_i} b_k * u_{ijk}  (exact linearization of a_{ij} * z_j)
+    for i in T:
+        for j in P:
+            model.addConstr(
+                q[i, j] == gp.quicksum(bk(k) * u[i, j, k] for k in K_i[i]),
+                name=f"q_def_{i}_{j}"
+            )
+
+    # (19) Demand fulfillment: sum_j q_{ij} + x_i >= d_i  for all i in T
+    for i in T:
+        model.addConstr(
+            gp.quicksum(q[i, j] for j in P) + x[i] >= d[i],
+            name=f"demand_{i}"
+        )
+
+    # (20) Extra pieces bound: sum_j z_j >= sum_i x_i
+    model.addConstr(
+        gp.quicksum(z[j] for j in P) >= gp.quicksum(x[i] for i in T),
+        name="extra_bound"
+    )
+
+    # (21) Symmetry-breaking: z_{j-1} >= z_j  for all j in P, j > 1
+    for j in P:
+        if j > 0:
+            model.addConstr(z[j - 1] >= z[j], name=f"sym_{j}")
+
+    # ------------------------------------------------------------------
+    # Solve
+    # ------------------------------------------------------------------
+    model.optimize()
+
+    # ------------------------------------------------------------------
+    # Extract solution
+    # ------------------------------------------------------------------
+    if model.SolCount > 0:
+        obj_val = model.ObjVal
+        s_sol = {j: int(round(s[j].X)) for j in P}
+        z_sol = {j: int(round(z[j].X)) for j in P}
+        x_sol = {i: x[i].X for i in T}
+        a_sol = {
+            (i, j): int(sum(bk(k) * round(w[i, j, k].X) for k in K_i[i]))
+            for i in T for j in P
+        }
+        q_sol = {(i, j): q[i, j].X for i in T for j in P}
+
+        solution = {
+            "objective_value": obj_val,
+            "status": "optimal" if model.status == GRB.OPTIMAL else "feasible_time_limit",
+            "patterns": {
+                str(j): {
+                    "used": bool(s_sol[j]),
+                    "repetitions": z_sol[j],
+                    "pieces": {
+                        str(products[i]["id"]): a_sol[i, j]
+                        for i in T
+                    },
+                    **(
+                        {"knife_count": int(round(knife_count[j].X))}
+                        if is_knife_dependent
+                        else {}
+                    ),
+                }
+                for j in P
+            },
+            "extra_pieces": {str(products[i]["id"]): x_sol[i] for i in T},
+            "production_quantities": {
+                f"product_{products[i]['id']}_pattern_{j}": q_sol[i, j]
+                for i in T for j in P
+            }
+        }
+    else:
+        solution = {
+            "objective_value": None,
+            "status": "no_feasible_solution_found"
+        }
+
+    with open(args.solution_path, "w") as f:
+        solution["runtime"] = time.time() - _GUROBI_CODE_START_TIME
+        json.dump(solution, f, indent=2)
+
+    print(f"Solution written to {args.solution_path}")
+    if solution.get("objective_value") is not None:
+        print(f"Objective value: {solution['objective_value']}")
+        print(f"Status: {solution['status']}")
+
+
+if __name__ == "__main__":
+    main()

delage2022/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

delage2022/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

delage2022/gurobi_solution/large_solution_2.json

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

delage2022/gurobi_solution/large_solution_3.json

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

delage2022/gurobi_solution_log/large_log_2.jsonl

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

delage2022/gurobi_solution_log/large_log_3.jsonl

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

delage2022/instance_schema.json

@@ -0,0 +1,21 @@
+{
+  "problem_type": "<str> One of 'open_ended_cscp', 'closed_ended_cscp', or 'cscp_with_knife_dependent_setups'.",
+  "machine_length": "<int> Length of the cutting machine in which patterns are configured.",
+  "num_products": "<int> Number of distinct product types to be cut.",
+  "num_patterns": "<int> Number of available cutting pattern slots.",
+  "num_groups": "<int> Number of product groups, where products sharing the same maximum pieces per pattern belong to the same group.",
+  "cost_setup_pattern": "<int> Time cost incurred once for each cutting pattern that is used.",
+  "cost_repetition": "<int> Time cost incurred for each repetition of any cutting pattern.",
+  "cost_knife_setup": "<number, optional> Additional setup time per knife; required only for cscp_with_knife_dependent_setups.",
+  "x_i_forced_zero": "<bool, optional> True for closed_ended_cscp, where all extra-piece quantities must be zero.",
+  "M": "<int> Upper bound on the number of repetitions any single pattern may have, equal to the maximum demand among all products.",
+  "products": [
+    {
+      "id": "<int> Unique identifier of the product type.",
+      "length": "<int> Length of one piece of this product type.",
+      "demand": "<int> Number of pieces of this product type that must be produced.",
+      "N_i": "<int> Maximum number of pieces of this product type that can fit within a single cutting pattern."
+    }
+  ],
+  "groups": "<dict, key: '{N_i_value}'> List of product IDs that share the same maximum pieces per pattern value, grouping products with identical fitting capacity."
+}

delage2022/mathematical_formulation.md

@@ -0,0 +1,79 @@
+# Original Formulation: Open-Ended Continuous Stock Cutting Problem (Open-Ended CSCP)
+
+*Source: Logic-Based Benders Decomposition for Integrated Process Configuration and Production Planning Problems, Karim Pérez Martı́nez, Yossiri Adulyasak, and Raf Jans, 2022 (original OP formulation of Hajizadeh and Lee, 2007).*
+
+## Sets and Parameters
+
+- $T$: set of product types, indexed by $i$.
+
+- $P$: set of cutting patterns, indexed by $j$.
+
+- $C_r$: time required for a single pattern use (cutting time per repetition).
+
+- $C_s$: setup time for a used pattern.
+
+- $d_i$: demand for product $i$.
+
+- $l_i$: length of product $i$.
+
+- $L$: length of the cutting machine.
+
+- $M$: large number, defined as $M = \max_{i \in T}\{d_i\}$.
+
+## Decision Variables
+
+- $s_j \in \{0,1\}$, $\forall j \in P$: 1 if pattern $j$ is used, 0 otherwise (configuration decision, part of $\mathbf{x}$).
+
+- $a_{ij} \in \mathbb{Z}_+$, $\forall i \in T, j \in P$: number of pieces of product $i$ in pattern $j$ (configuration decision, part of $\mathbf{x}$).
+
+- $z_j \in \mathbb{R}_+$, $\forall j \in P$: number of repetitions (uses) of pattern $j$ (production planning decision, part of $\mathbf{y}$).
+
+- $x_i \in \mathbb{R}_+$, $\forall i \in T$: units of product $i$ produced as extra pieces (production planning decision, part of $\mathbf{y}$).
+
+- $q_{ij} \in \mathbb{R}_+$, $\forall i \in T, j \in P$: units of product $i$ produced by pattern $j$ (production quantities).
+
+## Objective
+
+$$\begin{align}
+\text{OP:} \quad \min \quad \mathbf{c}^{\mathsf{T}}\mathbf{x} + \mathbf{d}^{\mathsf{T}}\mathbf{y} \;:\;
+\min \quad & C_s \sum_{j \in P} s_j + C_r \sum_{j \in P} z_j \tag{15}
+\end{align}$$
+
+## Constraints
+
+$$\begin{align}
+\mathbf{Ax} \ge \mathbf{a}: \quad & \sum_{i \in T} l_i\, a_{ij} \le L\, s_j,
+  & \forall j \in P, \tag{16}\\
+\mathbf{Bx} + \mathbf{Cy} \ge \mathbf{b}: \quad & z_j \le M\, s_j,
+  & \forall j \in P, \tag{17}\\
+\mathbf{q} = f(\mathbf{x},\mathbf{y}): \quad & q_{ij} = a_{ij}\, z_j,
+  & \forall i \in T,\; j \in P, \tag{18}\\
+\mathbf{Dy} + \mathbf{Eq} \ge \mathbf{e}: \quad & \sum_{j \in P} q_{ij} + x_i \ge d_i,
+  & \forall i \in T, \tag{19}\\
+& \sum_{j \in P} z_j \ge \sum_{i \in T} x_i, \tag{20}\\
+& z_{j-1} \ge z_j,
+  & \forall j \in P : j > 1, \tag{21}\\
+\mathbf{x} &\in \mathbb{B}^{|\mathcal{A}|} :\; s_j \in \{0,1\},\; a_{ij} \in \mathbb{Z}_+,
+  & \forall i \in T,\; j \in P, \tag{22}\\
+\mathbf{y} \in \mathbb{R}_+^{|\mathcal{B}|} \times \mathbb{Z}_+^{|\mathcal{C}|};\;
+  \mathbf{q} &\in \mathbb{R}_+^{|\mathcal{D}|} :\; x_i \ge 0,\; z_j \in \mathbb{Z}_+;\; q_{ij} \ge 0,
+  & \forall i \in T,\; j \in P. \tag{23}
+\end{align}$$
+
+The objective (15) minimizes the total setup and cutting time. Constraints (16) are the configuration (machine length) constraints, which ensure that the total length of the pieces in a used pattern does not exceed the machine length. Constraints (17) link the pattern-use indicator $s_j$ with the number of pattern repetitions $z_j$. **Constraints (18) are the nonlinear (bilinear) production quantity constraints**: the amount of product $i$ produced by pattern $j$ equals the product of the configuration variable $a_{ij}$ (pieces of $i$ per pattern $j$) and the production level $z_j$ (number of repetitions). Constraints (19) ensure demand fulfillment, allowing demand to be met jointly by patterns and extra pieces. Constraints (20) limit the total number of extra pieces by the total number of pattern repetitions. Symmetry-breaking inequalities (21) order the used patterns by the number of repetitions. Constraints (22)–(23) define the variable domains.
+
+## Paper-Supported Variants
+
+The closed-ended CSCP is the special case of (15)-(23) in which no extra pieces can be produced:
+
+$$x_i = 0, \qquad \forall i \in T.$$
+
+The open-ended CSCP with knife-dependent setups adds parameter $C_k$, the setup time per knife, and variable $n_j \ge 0$, the number of knives in pattern $j$. Its objective is
+
+$$\min\; C_s\sum_{j\in P}s_j + C_r\sum_{j\in P}z_j + C_k\sum_{j\in P}n_j,$$
+
+with the additional constraint from Section 1.1.2 of the online supplement,
+
+$$n_j \ge \sum_{i\in T}a_{ij} + M(s_j-1), \qquad \forall j\in P.$$
+
+Because $n_j$ has a positive objective coefficient, it equals the number of pieces cut simultaneously by each used pattern at optimum. All remaining open-ended constraints, including the extra-piece constraints, continue to apply to this variant.

delage2022/problem_description.txt

@@ -0,0 +1,9 @@
+# Problem Description
+
+A steel tube manufacturer operates a cutting machine that slices a continuous steel tube into smaller pieces of various product types. The machine has a fixed length, and it is configured using cutting patterns, each of which specifies how many pieces of each product type are cut simultaneously in a single pass. The machine may use multiple distinct patterns, and each pattern may be repeated multiple times. The input field `problem_type` selects one of three machine variants. In the open-ended variant, each repetition can additionally produce one extra piece of any product type beyond the configured pattern. In the closed-ended variant, the end wall prevents all such extra pieces. In the open-ended variant with knife-dependent setups, extra pieces are allowed, but setting up a used pattern incurs an additional cost proportional to the number of knives in that pattern. The number of knives equals the total number of pieces cut simultaneously by the pattern.
+
+The input data consists of a set of products and a set of available patterns. Each product has a known length and a known demand (the number of pieces required). The cutting machine has a known total length. Two time-cost parameters are always given: a fixed setup time incurred once for each pattern that is used, and a cutting time incurred once per repetition of any pattern. Knife-dependent instances additionally provide the setup cost per knife. Closed-ended instances explicitly indicate that extra-piece variables are forced to zero. A large number, equal to the maximum demand among all products, caps the number of repetitions any single pattern may have. For each product, the maximum number of pieces of that product that can fit within a single pattern is also given.
+
+The manufacturer must decide which patterns to use, how many pieces of each product type to include in each pattern, how many times to repeat each pattern, and, when the machine is open-ended, how many extra pieces of each product type to produce. The total number of units of each product produced by a given pattern equals the number of pieces of that product specified in that pattern multiplied by the number of repetitions of that pattern. If a pattern is not used, no pieces may be assigned to it. If a pattern is used, the sum of the lengths of all pieces assigned to it must not exceed the machine length. A pattern may have repetitions only if it has been set up for use, and its repetition count is limited by the large number described above. For every product, the total production from all patterns plus any permitted extra pieces must meet or exceed demand. In open-ended variants, the total number of extra pieces across all products must not exceed the total number of pattern repetitions. In the closed-ended variant, every extra-piece quantity must be zero. To avoid interchangeable orderings, patterns are ordered so that each repetition count is at least as large as the next. Piece counts and repetition counts must be nonnegative integers. Extra-piece quantities must be nonnegative. For a knife-dependent instance, the solution must also report each pattern's knife count, equal to the sum of its per-product piece counts.
+
+The goal is to minimize total time: fixed setup times for used patterns plus cutting times for all pattern repetitions. For a knife-dependent instance, the objective also includes the setup cost per knife multiplied by the total number of knives across all patterns.

delage2022/solution_schema.json

@@ -0,0 +1,13 @@
+{
+  "objective_value": "<float> Total time required, equal to fixed setup times plus repetition times and, for knife-dependent instances, knife setup times.",
+  "patterns": {
+    "<key: '{pattern_index}'>": {
+      "used": "<bool> Whether this pattern is selected for use on the cutting machine.",
+      "repetitions": "<int> Number of times this pattern is repeated on the cutting machine.",
+      "pieces": "<dict, key: '{product_id}'> Number of pieces of each product cut in a single pass of this pattern.",
+      "knife_count": "<int, conditionally required> For cscp_with_knife_dependent_setups, the total number of pieces cut in one pass of this pattern; omit for other variants."
+    }
+  },
+  "extra_pieces": "<dict, key: '{product_id}'> Number of extra pieces of each product produced via the open end; every value must be zero for closed_ended_cscp.",
+  "production_quantities": "<dict, key: 'product_{product_id}_pattern_{pattern_index}'> Total number of pieces of each product produced by each pattern, equal to the pieces per pass multiplied by the number of repetitions."
+}