Datasets:

frontieror
/

FrontierOR

@@ -1,156 +0,0 @@
-# Large binary / data files go through Git LFS.
-# Code, schemas, descriptions and the meta CSV stay as normal git blobs
-# so they are diffable and previewable on the Hub.
-instance/**                 filter=lfs diff=lfs merge=lfs -text
-gurobi_solution/**          filter=lfs diff=lfs merge=lfs -text
-gurobi_solution_log/**      filter=lfs diff=lfs merge=lfs -text
-gurobi_feasi_result/**      filter=lfs diff=lfs merge=lfs -text
-*.zip                       filter=lfs diff=lfs merge=lfs -text
-*.tar                       filter=lfs diff=lfs merge=lfs -text
-*.tar.gz                    filter=lfs diff=lfs merge=lfs -text
-*.npz                       filter=lfs diff=lfs merge=lfs -text
-*.parquet                   filter=lfs diff=lfs merge=lfs -text
-yang2013/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-yang2013/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-wangy2020/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-yang2013/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-yang2013/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-wangy2020/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-wangy2020/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-wangy2020/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-wu2022/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-sansegundo2023/instance/large_instance_31.json.pre_shrink_20260518_n3333 filter=lfs diff=lfs merge=lfs -text
-sansegundo2023/instance/large_instance_51.json.pre_shrink_20260518_n3333 filter=lfs diff=lfs merge=lfs -text
-sansegundo2023/instance/large_instance_41.json.pre_shrink_20260518_n3333 filter=lfs diff=lfs merge=lfs -text
-sansegundo2023/instance/large_instance_11.json.pre_shrink_20260518_n3333 filter=lfs diff=lfs merge=lfs -text
-castro2021/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/gurobi_solution/large_solution_1.json filter=lfs diff=lfs merge=lfs -text
-martello1999/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-martello1999/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-martello1999/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-klose2005/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-klose2005/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-martello1999/gurobi_solution/large_solution_1.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-wangk2020/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-wu2022/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-wu2022/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-klose2005/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-martello1999/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-klose2005/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-klose2005/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-wu2022/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-wu2022/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-sansegundo2023/instance/large_instance_21.json.pre_shrink_20260518_n3333 filter=lfs diff=lfs merge=lfs -text
-taninmis2022/gurobi_solution/large_solution_1.json filter=lfs diff=lfs merge=lfs -text
-castro2021/gurobi_solution/large_solution_1.json filter=lfs diff=lfs merge=lfs -text
-castro2021/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-kobayashi2021/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-castro2021/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-pedersen2024/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-cordeau2019/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-cordeau2019/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-hadjar2006/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-cordeau2019/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-cordeau2019/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-hadjar2006/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-pedersen2024/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-hadjar2006/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-pedersen2024/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-pedersen2024/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-hadjar2006/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-pedersen2024/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/gurobi_solution/large_solution_1.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-hewitt2024/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-hewitt2024/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-hewitt2024/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-hewitt2024/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-hewitt2024/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-segundo2019b/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-segundo2019b/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-segundo2019b/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-segundo2019b/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-segundo2019b/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/gurobi_solution/large_solution_1.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-belhoul2014/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-pettersson2020/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-segundo2019/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-segundo2019/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-segundo2019/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-delorme2020/gurobi_solution/large_solution_1.json filter=lfs diff=lfs merge=lfs -text
-delorme2020/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-delorme2020/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-delorme2020/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-lozano2017/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-lozano2017/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-lozano2017/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-lozano2017/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-lozano2017/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-gangammanavar2020/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-gangammanavar2020/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-gangammanavar2020/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-gangammanavar2020/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-damcikurt2016/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-yang2013/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-kobayashi2021/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-hadjar2006/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-kobayashi2021/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-kobayashi2021/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-kobayashi2021/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-taninmis2022/gurobi_solution/large_solution_4.json filter=lfs diff=lfs merge=lfs -text
-taninmis2022/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-mansini2020/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-mansini2020/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-mansini2020/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-taninmis2022/gurobi_solution/large_solution_3.json filter=lfs diff=lfs merge=lfs -text
-taninmis2022/gurobi_solution/large_solution_2.json filter=lfs diff=lfs merge=lfs -text
-martello1999/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-mansini2020/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-mansini2020/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-martello1999/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-martello1999/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-martello1999/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-martello1999/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-fragkos2021/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-castro2021/instance/large_instance_1.json filter=lfs diff=lfs merge=lfs -text
-castro2021/gurobi_solution/large_solution_5.json filter=lfs diff=lfs merge=lfs -text
-castro2021/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-castro2021/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-fragkos2021/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-fragkos2021/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text
-fragkos2021/instance/large_instance_3.json filter=lfs diff=lfs merge=lfs -text
-fragkos2021/instance/large_instance_2.json filter=lfs diff=lfs merge=lfs -text
-castro2021/instance/large_instance_4.json filter=lfs diff=lfs merge=lfs -text
-castro2021/instance/large_instance_5.json filter=lfs diff=lfs merge=lfs -text

README.md DELETED Viewed

@@ -1,91 +0,0 @@
----
-license: cc-by-4.0
-language:
-  - en
-pretty_name: Frontier-OR Benchmark
-size_categories:
-  - n<1K
-task_categories:
-  - other
-tags:
-  - operations-research
-  - optimization
-  - mixed-integer-programming
-  - gurobi
-  - benchmark
-  - llm-for-or
-configs:
-  - config_name: meta
-    data_files: paper_meta_info.json
----
-# Frontier-OR Benchmark
-A benchmark of **180 literature-grounded OR tasks**, each packaged as a
-self-contained reproducible unit: natural-language problem description,
-mathematical formulation, reference Gurobi implementation, test instances,
-reference solutions, and an automated feasibility checker.
-Designed for evaluating LLMs on the end-to-end task of turning a research
-paper's OR problem into runnable, verifiably-correct optimization code.
-## What's in each paper folder
-| File / dir | Purpose |
-| --- | --- |
-| `problem_description.txt` | Natural-language problem statement |
-| `mathematical_formulation.md` | Mathematical model (variables, constraints, objective) |
-| `gurobi_code.py` | Reference Gurobi implementation |
-| `feasibility_check.py` | Automated solution validator |
-| `solution_logger.py` | Utility for serializing solutions |
-| `instance_schema.json` | JSON schema for input instances |
-| `solution_schema.json` | JSON schema for solutions |
-| `instance/` | Test instances (JSON) |
-| `gurobi_solution/` | Reference solutions produced by `gurobi_code.py` |
-| `gurobi_solution_log/` | Anytime objective trajectory from the reference Gurobi run |
-| `gurobi_feasi_result/` | Output of `feasibility_check.py` on the reference solutions |
-<!-- ## Top-level files
-- `paper_meta_info.csv` / `paper_meta_info.json` — metadata for all 180 papers
-  (problem class, formulation type, application field, average instance size, etc.). -->
-<!-- ## Source PDFs
-The original paper PDFs are **not redistributed** here because copyright belongs
-to the respective publishers (INFORMS, Elsevier, Springer, etc.). Use the
-`paper_id`, `paper_title`, `publication`, and `year` columns in
-`paper_meta_info.csv` to look them up via your institution. -->
-## Loading the metadata
-```python
-from datasets import load_dataset
-meta = load_dataset("SmartOR/FrontierOR", "meta", split="train")
-print(meta[0])
-```
-For the per-paper instance / solution data, clone or download the full
-repository — the structure is intentionally a file tree, not a flat HF
-dataset, because each paper is its own reproducible package.
-```bash
-hf download SmartOR/FrontierOR --repo-type dataset --local-dir frontier-or
-```
-<!-- ## License
-Released under **CC-BY-4.0**. If you use this benchmark, please cite the
-accompanying paper (citation below) and respect the original publishers'
-copyright on the source PDFs. -->
-<!-- ## Citation
-```bibtex
-@misc{frontier-or-2026,
-  title  = {Frontier-OR: A Benchmark for LLM-Based Operations Research Code Generation},
-  author = {Kong, Minwei and others},
-  year   = {2026},
-  url    = {https://huggingface.co/datasets/SmartOR/FrontierOR}
-}
-``` -->

adulyasak2015/feasibility_check.py DELETED Viewed

@@ -1,683 +0,0 @@
-#!/usr/bin/env python3
-"""
-Feasibility checker for the Two-Stage Stochastic Production Routing Problem (2-SPRP).
-Reference: Adulyasak, Cordeau, Jans (2015), Operations Research.
-Checks all hard constraints from the mathematical formulation.
-Constraint numbering follows the paper's formulation section, counted from top to bottom:
-  Constraint 1  = Eq.(2):  Plant inventory flow balance (=)
-  Constraint 2  = Eq.(3):  Customer inventory flow balance (=)
-  Constraint 3  = Eq.(4):  Maximum inventory at plant (<=)
-  Constraint 4  = Eq.(5):  Maximum inventory at customers (<=)
-  Constraint 5  = Eq.(6):  Production capacity / setup (<=)
-  Constraint 6  = Eq.(7):  Vehicle load capacity (<=)
-  Constraint 7  = Eq.(8):  Delivery only if customer visited (<=)
-  Constraint 8  = Eq.(9):  Each customer visited at most once per period (<=)
-  Constraint 9  = Eq.(10): Degree constraints (=)
-  Constraint 10 = Eq.(11): Subtour elimination (<=)
-  Constraint 11 = Eq.(12): Nonnegativity of second-stage variables (>=)
-  Constraint 12 = Eq.(13): Binary y, z (domain)
-  Constraint 13 = Eq.(14): Binary x for non-depot edges (domain)
-  Constraint 14 = Eq.(15): x at depot edges in {0,1,2} (domain)
-  Constraint 15 = Eq.(16): Customer visit requires vehicle dispatch (<=)
-  Constraint 16 = Eq.(17): Edge implies both endpoints visited (<=)
-  Constraint 17 = Eq.(18): Vehicle symmetry breaking (>=)
-  Constraint 18 = Eq.(19): Lexicographic ordering of visits (>=)
-  Constraint 19 = Eq.(20): Nonanticipativity for p (=, M-SPRP only)
-  Constraint 20 = Eq.(21): Nonanticipativity for I (=, M-SPRP only)
-  Constraint 21 = Eq.(22): Nonanticipativity for e (=, M-SPRP only)
-  Constraint 22 = Eq.(23): Nonanticipativity for q (=, M-SPRP only)
-  Constraint 23 = Objective consistency (lower-bound check on reported obj)
-"""
-import argparse
-import json
-from collections import defaultdict
-def check_feasibility(data, sol):
-    tol = 1e-5
-    eps = 1e-5
-    n = data['n']
-    T = data['T']
-    m = data['m']
-    Q = data['Q']
-    C = data['C']
-    L = data['L']
-    I0 = data['I0']
-    demand_sc = data['demand_scenarios']
-    n_omega = data['n_scenarios']
-    problem_type = data.get('problem_type', '2-SPRP')
-    Nc = list(range(1, n + 1))
-    N = list(range(0, n + 1))
-    periods = list(range(1, T + 1))
-    vehicles = list(range(1, m + 1))
-    scenarios = list(range(n_omega))
-    edges = [(i, j) for i in N for j in N if i < j]
-    edges_Nc = [(i, j) for i in Nc for j in Nc if i < j]
-    def d(omega, i, t):
-        return demand_sc[omega][i - 1][t - 1]
-    def M_t_val(t, omega):
-        rem = sum(d(omega, ci, s) for ci in Nc for s in range(t, T + 1))
-        return min(C, Q, rem)
-    def M_prime_val(i, t, omega):
-        rem = sum(d(omega, i, s) for s in range(t, T + 1))
-        return min(L[i], Q, rem)
-    # --- Parse solution ---
-    y = {}
-    for key, val in sol.get('y', {}).items():
-        y[int(key)] = val
-    for t in periods:
-        y.setdefault(t, 0)
-    z = {}
-    for key, val in sol.get('z', {}).items():
-        parts = key.split('_')
-        i, k, t = int(parts[0]), int(parts[1]), int(parts[2])
-        z[i, k, t] = val
-    for i in N:
-        for k in vehicles:
-            for t in periods:
-                z.setdefault((i, k, t), 0)
-    x = {}
-    for key, val in sol.get('x', {}).items():
-        parts = key.split('_')
-        i, j, k, t = int(parts[0]), int(parts[1]), int(parts[2]), int(parts[3])
-        x[i, j, k, t] = val
-    for (i, j) in edges:
-        for k in vehicles:
-            for t in periods:
-                x.setdefault((i, j, k, t), 0)
-    violations_list = []  # list of (constraint_idx, message, lhs, rhs, raw_excess, normalizer, ratio)
-    violated_set = set()
-    def record_violation(constraint_idx, lhs, rhs, op, msg):
-        if op == '<=':
-            violation_amount = max(0.0, lhs - rhs)
-        elif op == '>=':
-            violation_amount = max(0.0, rhs - lhs)
-        elif op == '=':
-            violation_amount = abs(lhs - rhs)
-        else:
-            return
-        if violation_amount > tol:
-            normalizer = max(abs(rhs), eps)
-            ratio = violation_amount / normalizer
-            violated_set.add(constraint_idx)
-            violations_list.append({
-                'constraint': constraint_idx,
-                'msg': msg,
-                'lhs': float(lhs),
-                'rhs': float(rhs),
-                'raw_excess': float(violation_amount),
-                'normalizer': float(normalizer),
-                'ratio': float(ratio),
-            })
-    # =====================================================================
-    # Constraints 1-7 (Eqs. 2-8): Second-stage constraints
-    # These involve second-stage variables (p, I, q, e) not present in the
-    # solution. We construct feasible second-stage variables to verify.
-    # For any first-stage (y, z, x), feasible second-stage always exists
-    # because unmet demand variable e acts as slack.
-    # =====================================================================
-    # Construct feasible second-stage variables for each scenario
-    for omega in scenarios:
-        # Determine maximum production and delivery given first-stage decisions
-        # Greedy: produce as much as allowed, deliver as much as possible
-        # to minimize unmet demand (which always makes constraints feasible).
-        # Production capacity per period
-        p_max = {}
-        for t in periods:
-            p_max[t] = M_t_val(t, omega) * y[t]
-        # Delivery capacity per customer/vehicle/period
-        q_max = {}
-        for i_c in Nc:
-            for k in vehicles:
-                for t in periods:
-                    q_max[i_c, k, t] = M_prime_val(i_c, t, omega) * z[i_c, k, t]
-        # Vehicle load limit per vehicle/period
-        veh_cap = {}
-        for k in vehicles:
-            for t in periods:
-                veh_cap[k, t] = Q * z[0, k, t]
-        # Forward simulation: allocate production and deliveries
-        I_plant = {0: float(I0[0])}
-        I_cust = {}
-        for i_c in Nc:
-            I_cust[i_c, 0] = float(I0[i_c])
-        p_val = {}
-        q_val = {}
-        e_val = {}
-        for t in periods:
-            # Determine total demand and delivery needs
-            total_need = 0.0
-            for i_c in Nc:
-                need = max(0.0, d(omega, i_c, t) - I_cust[i_c, t - 1])
-                total_need += need
-            # Production: produce up to capacity, limited by plant storage
-            produce = min(p_max[t], total_need, L[0] - I_plant[t - 1] + total_need)
-            produce = max(0.0, produce)
-            p_val[t] = produce
-            # Available at plant for delivery
-            available = I_plant[t - 1] + produce
-            # Allocate deliveries: respect vehicle capacity and customer visit
-            total_delivered = 0.0
-            for k in vehicles:
-                veh_remaining = veh_cap[k, t]
-                for i_c in Nc:
-                    cap = min(q_max[i_c, k, t], veh_remaining,
-                              max(0.0, available - total_delivered))
-                    # Deliver up to demand shortfall
-                    need = max(0.0, d(omega, i_c, t) - I_cust[i_c, t - 1])
-                    deliver = min(cap, need)
-                    q_val[i_c, k, t] = deliver
-                    veh_remaining -= deliver
-                    total_delivered += deliver
-            # Update plant inventory
-            I_plant[t] = I_plant[t - 1] + p_val[t] - total_delivered
-            # Update customer inventories and unmet demand
-            for i_c in Nc:
-                delivery = sum(q_val[i_c, k, t] for k in vehicles)
-                dem = d(omega, i_c, t)
-                prev = I_cust[i_c, t - 1]
-                # Balance: prev + delivery + e = dem + I_new
-                I_cust[i_c, t] = max(0.0, prev + delivery - dem)
-                e_val[i_c, t] = max(0.0, dem - prev - delivery)
-            # --- Constraint 1 (Eq.2): Plant inventory balance ---
-            lhs = I_plant[t - 1] + p_val[t]
-            rhs = total_delivered + I_plant[t]
-            record_violation(1, lhs, rhs, '=',
-                f"Constraint 1 (Eq.2): Plant balance violated in period {t}, scenario {omega}: "
-                f"LHS={lhs:.6f} != RHS={rhs:.6f}")
-            # --- Constraint 3 (Eq.4): Plant inventory capacity ---
-            record_violation(3, I_plant[t], float(L[0]), '<=',
-                f"Constraint 3 (Eq.4): Plant inventory {I_plant[t]:.4f} > capacity {L[0]} "
-                f"in period {t}, scenario {omega}")
-            # --- Constraint 5 (Eq.6): Production capacity ---
-            record_violation(5, p_val[t], p_max[t], '<=',
-                f"Constraint 5 (Eq.6): Production {p_val[t]:.4f} > capacity {p_max[t]:.4f} "
-                f"in period {t}, scenario {omega}")
-            for i_c in Nc:
-                delivery = sum(q_val[i_c, k, t] for k in vehicles)
-                dem = d(omega, i_c, t)
-                # --- Constraint 2 (Eq.3): Customer inventory balance ---
-                lhs2 = I_cust[i_c, t - 1] + delivery + e_val[i_c, t]
-                rhs2 = dem + I_cust[i_c, t]
-                record_violation(2, lhs2, rhs2, '=',
-                    f"Constraint 2 (Eq.3): Customer {i_c} balance violated in period {t}, "
-                    f"scenario {omega}: LHS={lhs2:.6f} != RHS={rhs2:.6f}")
-                # --- Constraint 4 (Eq.5): Customer inventory capacity ---
-                record_violation(4, I_cust[i_c, t] + dem, float(L[i_c]), '<=',
-                    f"Constraint 4 (Eq.5): Customer {i_c} inventory+demand "
-                    f"{I_cust[i_c, t] + dem:.4f} > capacity {L[i_c]} "
-                    f"in period {t}, scenario {omega}")
-                # --- Constraint 7 (Eq.8): Delivery only if visited ---
-                for k in vehicles:
-                    mp = M_prime_val(i_c, t, omega) * z[i_c, k, t]
-                    record_violation(7, q_val[i_c, k, t], mp, '<=',
-                        f"Constraint 7 (Eq.8): Delivery to customer {i_c} by vehicle {k} "
-                        f"in period {t}, scenario {omega}: {q_val[i_c, k, t]:.4f} > {mp:.4f}")
-            # --- Constraint 6 (Eq.7): Vehicle load capacity ---
-            for k in vehicles:
-                total_load = sum(q_val[i_c, k, t] for i_c in Nc)
-                cap_rhs = Q * z[0, k, t]
-                record_violation(6, total_load, float(cap_rhs), '<=',
-                    f"Constraint 6 (Eq.7): Vehicle {k} load {total_load:.4f} > capacity "
-                    f"{cap_rhs:.4f} in period {t}, scenario {omega}")
-        # --- Constraint 11 (Eq.12): Nonnegativity ---
-        for t in periods:
-            record_violation(11, 0.0, p_val[t], '<=',
-                f"Constraint 11 (Eq.12): p_{t} negative ({p_val[t]:.6f}) in scenario {omega}")
-            record_violation(11, 0.0, I_plant[t], '<=',
-                f"Constraint 11 (Eq.12): I_plant_{t} negative ({I_plant[t]:.6f}) in scenario {omega}")
-            for i_c in Nc:
-                record_violation(11, 0.0, I_cust[i_c, t], '<=',
-                    f"Constraint 11 (Eq.12): I_{i_c}_{t} negative ({I_cust[i_c, t]:.6f}) "
-                    f"in scenario {omega}")
-                record_violation(11, 0.0, e_val[i_c, t], '<=',
-                    f"Constraint 11 (Eq.12): e_{i_c}_{t} negative ({e_val[i_c, t]:.6f}) "
-                    f"in scenario {omega}")
-                for k in vehicles:
-                    record_violation(11, 0.0, q_val[i_c, k, t], '<=',
-                        f"Constraint 11 (Eq.12): q_{i_c}_{k}_{t} negative "
-                        f"({q_val[i_c, k, t]:.6f}) in scenario {omega}")
-    # =====================================================================
-    # Constraint 8 (Eq.9): Each customer visited at most once per period
-    # sum_k z_{ikt} <= 1  for all i in Nc, t in T
-    # =====================================================================
-    for i_c in Nc:
-        for t in periods:
-            lhs = sum(z[i_c, k, t] for k in vehicles)
-            record_violation(8, float(lhs), 1.0, '<=',
-                f"Constraint 8 (Eq.9): Customer {i_c} visited {lhs} times "
-                f"(> 1) in period {t}")
-    # =====================================================================
-    # Constraint 9 (Eq.10): Degree constraints
-    # sum_{(j,j') in delta(i)} x_{jj'kt} = 2 * z_{ikt}
-    # =====================================================================
-    for i_node in N:
-        for k in vehicles:
-            for t in periods:
-                inc_edges = [(a, b) for (a, b) in edges if a == i_node or b == i_node]
-                lhs = sum(x[a, b, k, t] for (a, b) in inc_edges)
-                rhs = 2.0 * z[i_node, k, t]
-                record_violation(9, float(lhs), float(rhs), '=',
-                    f"Constraint 9 (Eq.10): Degree of node {i_node} by vehicle {k} "
-                    f"in period {t}: sum_edges={lhs} != 2*z={rhs}")
-    # =====================================================================
-    # Constraint 10 (Eq.11): Subtour elimination
-    # For each vehicle k and period t, check that visited customers form
-    # a connected component through the depot (no customer-only subtours).
-    # =====================================================================
-    for k in vehicles:
-        for t in periods:
-            visited = [i_c for i_c in Nc if z[i_c, k, t] > 0.5]
-            if len(visited) < 2:
-                continue
-            # Build adjacency among all nodes with edges
-            adj = defaultdict(set)
-            for (a, b) in edges:
-                if x[a, b, k, t] > 0.5:
-                    adj[a].add(b)
-                    adj[b].add(a)
-            # BFS from depot to find reachable customers
-            reachable = set()
-            stack = [0]
-            seen = set()
-            while stack:
-                node = stack.pop()
-                if node in seen:
-                    continue
-                seen.add(node)
-                if node in visited:
-                    reachable.add(node)
-                for nb in adj[node]:
-                    if nb not in seen:
-                        stack.append(nb)
-            # Customers visited but not reachable from depot form subtours
-            subtour_nodes = set(visited) - reachable
-            if subtour_nodes:
-                # Find the subtour components
-                remaining = set(subtour_nodes)
-                while remaining:
-                    start = next(iter(remaining))
-                    comp = set()
-                    stack = [start]
-                    while stack:
-                        node = stack.pop()
-                        if node in comp:
-                            continue
-                        comp.add(node)
-                        for nb in adj[node]:
-                            if nb in remaining and nb not in comp:
-                                stack.append(nb)
-                    remaining -= comp
-                    S = comp
-                    # Compute violation: sum x_{ij} for (i,j) in E(S) <= sum z - z_e
-                    E_S = [(a, b) for (a, b) in edges if a in S and b in S]
-                    sum_x = sum(x[a, b, k, t] for (a, b) in E_S)
-                    for e_node in S:
-                        rhs_val = sum(z[i_c, k, t] for i_c in S) - z[e_node, k, t]
-                        violation_amount = max(0.0, sum_x - rhs_val)
-                        if violation_amount > tol:
-                            normalizer = max(abs(rhs_val), eps)
-                            ratio = violation_amount / normalizer
-                            violated_set.add(10)
-                            violations_list.append({
-                                'constraint': 10,
-                                'msg': (f"Constraint 10 (Eq.11): Subtour among customers "
-                                        f"{sorted(S)} by vehicle {k} in period {t}"),
-                                'lhs': float(sum_x),
-                                'rhs': float(rhs_val),
-                                'raw_excess': float(violation_amount),
-                                'normalizer': float(normalizer),
-                                'ratio': float(ratio),
-                            })
-                            break  # one violation per component suffices
-    # =====================================================================
-    # Constraint 12 (Eq.13): Binary y_t, z_{ikt}
-    # =====================================================================
-    for t in periods:
-        val = y[t]
-        if abs(val - round(val)) > tol or round(val) not in (0, 1):
-            record_violation(12, float(val), float(round(val)), '=',
-                f"Constraint 12 (Eq.13): y_{t} = {val} is not binary")
-    for i_node in N:
-        for k in vehicles:
-            for t in periods:
-                val = z[i_node, k, t]
-                if abs(val - round(val)) > tol or round(val) not in (0, 1):
-                    record_violation(12, float(val), float(round(val)), '=',
-                        f"Constraint 12 (Eq.13): z_{i_node}_{k}_{t} = {val} is not binary")
-    # =====================================================================
-    # Constraint 13 (Eq.14): Binary x for non-depot edges (i != 0)
-    # =====================================================================
-    for (i_e, j_e) in edges:
-        if i_e == 0:
-            continue
-        for k in vehicles:
-            for t in periods:
-                val = x[i_e, j_e, k, t]
-                if abs(val - round(val)) > tol or round(val) not in (0, 1):
-                    record_violation(13, float(val), float(round(val)), '=',
-                        f"Constraint 13 (Eq.14): x_{i_e}_{j_e}_{k}_{t} = {val} "
-                        f"is not binary (non-depot edge)")
-    # =====================================================================
-    # Constraint 14 (Eq.15): x at depot edges in {0, 1, 2}
-    # =====================================================================
-    for j_e in Nc:
-        for k in vehicles:
-            for t in periods:
-                val = x[0, j_e, k, t]
-                if abs(val - round(val)) > tol or round(val) not in (0, 1, 2):
-                    record_violation(14, float(val), float(round(val)), '=',
-                        f"Constraint 14 (Eq.15): x_0_{j_e}_{k}_{t} = {val} "
-                        f"not in {{0,1,2}} (depot edge)")
-    # =====================================================================
-    # Constraint 15 (Eq.16): z_{ikt} <= z_{0kt} for i in Nc
-    # =====================================================================
-    for i_c in Nc:
-        for k in vehicles:
-            for t in periods:
-                lhs = float(z[i_c, k, t])
-                rhs = float(z[0, k, t])
-                record_violation(15, lhs, rhs, '<=',
-                    f"Constraint 15 (Eq.16): z_{i_c}_{k}_{t}={lhs} > "
-                    f"z_0_{k}_{t}={rhs} (customer visited without vehicle dispatch)")
-    # =====================================================================
-    # Constraint 16 (Eq.17): x_{ijkt} <= z_{ikt} and x_{ijkt} <= z_{jkt}
-    # for (i,j) in E(Nc)
-    # =====================================================================
-    for (i_e, j_e) in edges_Nc:
-        for k in vehicles:
-            for t in periods:
-                val = float(x[i_e, j_e, k, t])
-                zi = float(z[i_e, k, t])
-                zj = float(z[j_e, k, t])
-                record_violation(16, val, zi, '<=',
-                    f"Constraint 16 (Eq.17): x_{i_e}_{j_e}_{k}_{t}={val} > "
-                    f"z_{i_e}_{k}_{t}={zi}")
-                record_violation(16, val, zj, '<=',
-                    f"Constraint 16 (Eq.17): x_{i_e}_{j_e}_{k}_{t}={val} > "
-                    f"z_{j_e}_{k}_{t}={zj}")
-    # =====================================================================
-    # Constraint 17 (Eq.18): z_{0kt} >= z_{0,k+1,t} (vehicle symmetry)
-    # Only applies when m > 1
-    # =====================================================================
-    if m > 1:
-        for k in range(1, m):
-            for t in periods:
-                lhs = float(z[0, k, t])
-                rhs = float(z[0, k + 1, t])
-                record_violation(17, lhs, rhs, '>=',
-                    f"Constraint 17 (Eq.18): z_0_{k}_{t}={lhs} < "
-                    f"z_0_{k+1}_{t}={rhs} (vehicle ordering violated)")
-    # =====================================================================
-    # Constraint 18 (Eq.19): Lexicographic ordering
-    # sum_{i=1}^{j} 2^{j-i} z_{ikt} >= sum_{i=1}^{j} 2^{j-i} z_{i,k+1,t}
-    # Only applies when m > 1
-    # =====================================================================
-    if m > 1:
-        for j_node in Nc:
-            for k in range(1, m):
-                for t in periods:
-                    lhs = sum(2 ** (j_node - i_c) * z[i_c, k, t]
-                              for i_c in range(1, j_node + 1))
-                    rhs = sum(2 ** (j_node - i_c) * z[i_c, k + 1, t]
-                              for i_c in range(1, j_node + 1))
-                    record_violation(18, float(lhs), float(rhs), '>=',
-                        f"Constraint 18 (Eq.19): Lexicographic ordering violated "
-                        f"for j={j_node}, k={k}, t={t}: {lhs} < {rhs}")
-    # =====================================================================
-    # Constraints 19-22 (Eqs.20-23): Nonanticipativity (M-SPRP only)
-    # These only apply to multistage problems. For 2-SPRP, first-stage
-    # variables are scenario-independent by construction, so these are
-    # trivially satisfied.
-    # =====================================================================
-    # (Skipped for 2-SPRP; the solution format already has scenario-independent y, z, x.)
-    # =====================================================================
-    # Constraint 23: Objective-value consistency (Tier C anti-exploit check)
-    # Envelope check: reported objective_value must fall in [obj_lower,
-    # obj_upper], where both bounds are derivable from the first-stage
-    # variables (y, z, x) and instance data alone (the second-stage
-    # p, I, q, e are not in the solution schema).
-    #
-    # LOWER BOUND (rejects obj=0 / "do-nothing" exploit):
-    #   setup_floor  = f * sum_t y_t                            (exact)
-    #   transp_floor = sum_{i,j,k,t} c_{ij} * x_{ijkt}          (exact)
-    #   production cost >= 0, holding cost >= 0                 (omitted)
-    #   unmet penalty (general case): >= 0                      (omitted)
-    #   unmet penalty (do-nothing, sum_y == 0): EXACTLY
-    #     sum_w prob_w * sum_i sigma_i * max(0, total_demand_iw - I0_i)
-    #     because with no production, all customer demand beyond initial
-    #     inventory must be unmet -> the bound is tight in this case.
-    #
-    # UPPER BOUND (rejects obj=MAX_FLOAT / arbitrarily-huge exploit):
-    #   setup       = exact (as above)
-    #   transp      = exact (as above)
-    #   production <= u * C * sum_y                  (capacity-bound, scenario-indep)
-    #   unmet      <= sum_w prob_w * sum_i sigma_i * sum_t d_itw
-    #   holding    <= T * (h_0 * L_0 + sum_{i in Nc} h_i * L_i)
-    # =====================================================================
-    reported_obj = sol.get('objective_value')
-    try:
-        reported = float(reported_obj) if reported_obj is not None else None
-    except (TypeError, ValueError):
-        reported = None
-    if reported is not None:
-        f_cost = float(data.get('f', 0.0))
-        u_cost = float(data.get('u', 0.0))
-        h_vec = data.get('h')
-        transp_costs = data.get('transportation_costs')
-        probs = data.get('scenario_probabilities')
-        sigma = data.get('sigma')
-        sum_y = sum(float(y[t]) for t in periods)
-        setup = f_cost * sum_y
-        transp = 0.0
-        if transp_costs is not None:
-            for (i_e, j_e) in edges:
-                for k in vehicles:
-                    for t in periods:
-                        transp += float(transp_costs[i_e][j_e]) * float(x[i_e, j_e, k, t])
-        # Tight unmet-demand floor in the do-nothing case (no production at all).
-        unmet_floor = 0.0
-        if (abs(sum_y) <= tol and probs is not None and sigma is not None):
-            for w in scenarios:
-                pw = float(probs[w])
-                for i_c in Nc:
-                    total_d = sum(float(d(w, i_c, t)) for t in periods)
-                    unmet_floor += pw * float(sigma[i_c - 1]) * max(0.0, total_d - float(I0[i_c]))
-        obj_lower = setup + transp + unmet_floor
-        # Worst-case upper bound from first-stage decisions + instance data.
-        prod_upper = u_cost * float(C) * sum_y
-        unmet_upper = 0.0
-        if probs is not None and sigma is not None:
-            for w in scenarios:
-                pw = float(probs[w])
-                for i_c in Nc:
-                    total_d = sum(float(d(w, i_c, t)) for t in periods)
-                    unmet_upper += pw * float(sigma[i_c - 1]) * total_d
-        hold_upper = 0.0
-        if h_vec is not None:
-            hold_upper = float(T) * (
-                float(h_vec[0]) * float(L[0])
-                + sum(float(h_vec[i_c]) * float(L[i_c]) for i_c in Nc)
-            )
-        obj_upper = setup + transp + prod_upper + unmet_upper + hold_upper
-        tol_obj_lo = max(1e-3, 1e-3 * abs(obj_lower))
-        tol_obj_hi = max(1e-3, 1e-3 * abs(obj_upper))
-        shortfall = obj_lower - reported
-        overshoot = reported - obj_upper
-        if shortfall > tol_obj_lo:
-            normalizer = max(abs(obj_lower), eps)
-            ratio = shortfall / normalizer
-            violated_set.add(23)
-            bound_components = (
-                f"setup={setup:.4f}, transp={transp:.4f}, "
-                f"unmet(do-nothing)={unmet_floor:.4f}"
-                if abs(sum_y) <= tol
-                else f"setup={setup:.4f}, transp={transp:.4f}, unmet>=0"
-            )
-            violations_list.append({
-                'constraint': 23,
-                'msg': (
-                    f"Constraint 23 (Objective consistency): reported objective_value="
-                    f"{reported:.6f} is below the lower bound obj_lower={obj_lower:.6f} "
-                    f"({bound_components}); shortfall={shortfall:.6g}, tol={tol_obj_lo:.6g}"
-                ),
-                'lhs': float(obj_lower),
-                'rhs': float(reported),
-                'raw_excess': float(shortfall),
-                'normalizer': float(normalizer),
-                'ratio': float(ratio),
-            })
-        if overshoot > tol_obj_hi:
-            normalizer = max(abs(obj_upper), eps)
-            ratio = overshoot / normalizer
-            violated_set.add(23)
-            violations_list.append({
-                'constraint': 23,
-                'msg': (
-                    f"Constraint 23 (Objective consistency): reported objective_value="
-                    f"{reported:.6f} exceeds worst-case upper bound obj_upper={obj_upper:.6f} "
-                    f"(setup={setup:.4f}, transp={transp:.4f}, prod_max={prod_upper:.4f}, "
-                    f"unmet_max={unmet_upper:.4f}, hold_max={hold_upper:.4f}); "
-                    f"overshoot={overshoot:.6g}, tol={tol_obj_hi:.6g}"
-                ),
-                'lhs': float(reported),
-                'rhs': float(obj_upper),
-                'raw_excess': float(overshoot),
-                'normalizer': float(normalizer),
-                'ratio': float(ratio),
-            })
-    # =====================================================================
-    # Aggregate results
-    # =====================================================================
-    # Build unique violation messages per constraint
-    msg_per_constraint = defaultdict(list)
-    for v in violations_list:
-        msg_per_constraint[v['constraint']].append(v['msg'])
-    # Deduplicate messages: summarize if too many
-    final_messages = []
-    for c_idx in sorted(violated_set):
-        msgs = msg_per_constraint[c_idx]
-        if len(msgs) <= 3:
-            final_messages.extend(msgs)
-        else:
-            final_messages.append(msgs[0])
-            final_messages.append(f"  ... and {len(msgs) - 1} more violations of Constraint {c_idx}")
-    # Build violation_magnitudes (all entries)
-    final_magnitudes = []
-    for v in violations_list:
-        final_magnitudes.append({
-            'constraint': v['constraint'],
-            'lhs': v['lhs'],
-            'rhs': v['rhs'],
-            'raw_excess': v['raw_excess'],
-            'normalizer': v['normalizer'],
-            'ratio': v['ratio'],
-        })
-    result = {
-        'feasible': len(violated_set) == 0,
-        'violated_constraints': sorted(violated_set),
-        'violations': final_messages,
-        'violation_magnitudes': final_magnitudes,
-    }
-    return result
-def main():
-    parser = argparse.ArgumentParser(
-        description="Feasibility checker for the Stochastic Production Routing Problem"
-    )
-    parser.add_argument('--instance_path', type=str, required=True,
-                        help="Path to JSON instance file")
-    parser.add_argument('--solution_path', type=str, required=True,
-                        help="Path to JSON solution file")
-    parser.add_argument('--result_path', type=str, required=True,
-                        help="Path to write JSON feasibility result")
-    args = parser.parse_args()
-    with open(args.instance_path) as f:
-        data = json.load(f)
-    with open(args.solution_path) as f:
-        sol = json.load(f)
-    result = check_feasibility(data, sol)
-    with open(args.result_path, 'w') as f:
-        json.dump(result, f, indent=2)
-    if result['feasible']:
-        print("FEASIBLE: All hard constraints satisfied.")
-    else:
-        print(f"INFEASIBLE: {len(result['violated_constraints'])} constraint(s) violated: "
-              f"{result['violated_constraints']}")
-        for msg in result['violations']:
-            print(f"  - {msg}")
-if __name__ == '__main__':
-    main()

adulyasak2015/gurobi_code.py DELETED Viewed

@@ -1,366 +0,0 @@
-"""
-Gurobi implementation of the Two-Stage Stochastic Production Routing Problem (2-SPRP).
-Model (1)-(19): 2-BF (Two-Stage Base Formulation).
-Reference: Adulyasak, Cordeau, Jans (2015), Operations Research.
-"""
-import argparse
-import json
-import math
-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/).
-_repo = _os.path.dirname(_os.path.abspath(__file__))
-while _repo != _os.path.dirname(_repo) and not _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
-    _repo = _os.path.dirname(_repo)
-if _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
-    _sys.path.insert(0, _repo)
-try:
-    from scripts.utils.gurobi_log_helper import install_gurobi_logger
-except ImportError:
-    def install_gurobi_logger(log_path):  # no-op fallback when scripts/ unavailable
-        pass
-def load_instance(path):
-    with open(path) as f:
-        return json.load(f)
-def solve(instance_path, solution_path, time_limit):
-    data = load_instance(instance_path)
-    n = data['n']           # number of customers
-    T = data['T']           # number of periods
-    m = data['m']           # number of vehicles
-    Q = data['Q']           # vehicle capacity
-    C = data['C']           # production capacity per period
-    f_cost = data['f']      # fixed production setup cost
-    u = data['u']           # unit production cost
-    h = data['h']           # holding costs, h[0]=plant, h[1..n]=customers
-    L = data['L']           # inventory capacities, L[0]=plant, L[1..n]=customers
-    I0 = data['I0']         # initial inventories
-    sigma = data['sigma']   # penalty costs for customers (list of length n)
-    c = data['transportation_costs']  # c[i][j], i,j in 0..n
-    rho = data['scenario_probabilities']   # rho[omega]
-    demand_sc = data['demand_scenarios']   # demand_sc[omega][cust_idx][period_idx] (0-indexed)
-    n_omega = data['n_scenarios']
-    # Index sets (1-indexed periods, vehicles; 0-indexed customers shifted by 1)
-    Nc = list(range(1, n + 1))        # customers
-    N = list(range(0, n + 1))         # all nodes (0=plant)
-    periods = list(range(1, T + 1))
-    vehicles = list(range(1, m + 1))
-    scenarios = list(range(n_omega))
-    # All undirected edges (i<j)
-    edges = [(i, j) for i in N for j in N if i < j]
-    edges_Nc = [(i, j) for i in Nc for j in Nc if i < j]
-    def d(omega, i, t):
-        """Demand of customer i (1-indexed) in period t (1-indexed) under scenario omega."""
-        return demand_sc[omega][i - 1][t - 1]
-    def M_t(t, omega):
-        """M_{t,omega} = min{C, Q, sum_{s>=t, i in Nc} d_{is,omega}}"""
-        rem = sum(d(omega, i, s) for i in Nc for s in range(t, T + 1))
-        return min(C, Q, rem)
-    def M_prime(i, t, omega):
-        """M'_{it,omega} = min{L_i, Q, sum_{s>=t} d_{is,omega}}"""
-        rem = sum(d(omega, i, s) for s in range(t, T + 1))
-        return min(L[i], Q, rem)
-    # ----------------------------------------------------------------
-    model = gp.Model("2SPRP_2BF")
-    model.setParam("Threads", 1)
-    model.setParam("TimeLimit", time_limit)
-    model.setParam("LazyConstraints", 1)
-    # --- First-stage variables ---
-    y = {t: model.addVar(vtype=GRB.BINARY, name=f"y_{t}") for t in periods}
-    z = {}
-    for i in N:
-        for k in vehicles:
-            for t in periods:
-                z[i, k, t] = model.addVar(vtype=GRB.BINARY, name=f"z_{i}_{k}_{t}")
-    x = {}
-    for (i, j) in edges:
-        for k in vehicles:
-            for t in periods:
-                if i == 0:
-                    # Depot edge: can be traversed 0,1,2 times (out-and-back)
-                    x[i, j, k, t] = model.addVar(vtype=GRB.INTEGER, lb=0, ub=2,
-                                                  name=f"x_{i}_{j}_{k}_{t}")
-                else:
-                    x[i, j, k, t] = model.addVar(vtype=GRB.BINARY,
-                                                  name=f"x_{i}_{j}_{k}_{t}")
-    # --- Second-stage variables ---
-    p = {}
-    I_var = {}
-    q_var = {}
-    e_var = {}
-    for omega in scenarios:
-        for t in periods:
-            p[t, omega] = model.addVar(lb=0.0, name=f"p_{t}_{omega}")
-        for i in N:
-            for t in periods:
-                I_var[i, t, omega] = model.addVar(lb=0.0, name=f"I_{i}_{t}_{omega}")
-        for i in Nc:
-            for t in periods:
-                e_var[i, t, omega] = model.addVar(lb=0.0, name=f"e_{i}_{t}_{omega}")
-            for k in vehicles:
-                for t in periods:
-                    q_var[i, k, t, omega] = model.addVar(lb=0.0, name=f"q_{i}_{k}_{t}_{omega}")
-    model.update()
-    # --- Objective (1) ---
-    routing_cost = gp.quicksum(
-        c[i][j] * x[i, j, k, t]
-        for (i, j) in edges for k in vehicles for t in periods
-    )
-    setup_cost = gp.quicksum(f_cost * y[t] for t in periods)
-    second_stage = gp.quicksum(
-        rho[omega] * (
-            gp.quicksum(u * p[t, omega] for t in periods)
-            + gp.quicksum(h[i] * I_var[i, t, omega] for i in N for t in periods)
-            + gp.quicksum(sigma[i - 1] * e_var[i, t, omega] for i in Nc for t in periods)
-        )
-        for omega in scenarios
-    )
-    model.setObjective(setup_cost + routing_cost + second_stage, GRB.MINIMIZE)
-    # --- Constraint (2): Plant inventory balance ---
-    for t in periods:
-        for omega in scenarios:
-            I_prev = I0[0] if t == 1 else I_var[0, t - 1, omega]
-            model.addConstr(
-                I_prev + p[t, omega]
-                == gp.quicksum(q_var[i, k, t, omega] for i in Nc for k in vehicles)
-                + I_var[0, t, omega],
-                name=f"plant_bal_{t}_{omega}"
-            )
-    # --- Constraint (3): Customer inventory balance ---
-    for i in Nc:
-        for t in periods:
-            for omega in scenarios:
-                I_prev = I0[i] if t == 1 else I_var[i, t - 1, omega]
-                model.addConstr(
-                    I_prev + gp.quicksum(q_var[i, k, t, omega] for k in vehicles)
-                    + e_var[i, t, omega]
-                    == d(omega, i, t) + I_var[i, t, omega],
-                    name=f"cust_bal_{i}_{t}_{omega}"
-                )
-    # --- Constraint (4): Max plant inventory ---
-    for t in periods:
-        for omega in scenarios:
-            model.addConstr(I_var[0, t, omega] <= L[0], name=f"plant_inv_{t}_{omega}")
-    # --- Constraint (5): Max customer inventory ---
-    for i in Nc:
-        for t in periods:
-            for omega in scenarios:
-                model.addConstr(
-                    I_var[i, t, omega] + d(omega, i, t) <= L[i],
-                    name=f"cust_inv_{i}_{t}_{omega}"
-                )
-    # --- Constraint (6): Production capacity ---
-    for t in periods:
-        for omega in scenarios:
-            model.addConstr(
-                p[t, omega] <= M_t(t, omega) * y[t],
-                name=f"prod_cap_{t}_{omega}"
-            )
-    # --- Constraint (7): Vehicle load capacity ---
-    for k in vehicles:
-        for t in periods:
-            for omega in scenarios:
-                model.addConstr(
-                    gp.quicksum(q_var[i, k, t, omega] for i in Nc) <= Q * z[0, k, t],
-                    name=f"veh_load_{k}_{t}_{omega}"
-                )
-    # --- Constraint (8): Delivery only if customer visited ---
-    for i in Nc:
-        for k in vehicles:
-            for t in periods:
-                for omega in scenarios:
-                    model.addConstr(
-                        q_var[i, k, t, omega] <= M_prime(i, t, omega) * z[i, k, t],
-                        name=f"del_cap_{i}_{k}_{t}_{omega}"
-                    )
-    # --- Constraint (9): Each customer visited at most once per period ---
-    for i in Nc:
-        for t in periods:
-            model.addConstr(
-                gp.quicksum(z[i, k, t] for k in vehicles) <= 1,
-                name=f"visit_{i}_{t}"
-            )
-    # --- Constraint (10): Degree constraints ---
-    for i in N:
-        for k in vehicles:
-            for t in periods:
-                inc = [(a, b) for (a, b) in edges if a == i or b == i]
-                model.addConstr(
-                    gp.quicksum(x[a, b, k, t] for (a, b) in inc) == 2 * z[i, k, t],
-                    name=f"degree_{i}_{k}_{t}"
-                )
-    # --- Valid inequality (16): z_{ikt} <= z_{0kt} ---
-    for i in Nc:
-        for k in vehicles:
-            for t in periods:
-                model.addConstr(z[i, k, t] <= z[0, k, t], name=f"dispatch_{i}_{k}_{t}")
-    # --- Valid inequality (17): edge implies both endpoints visited ---
-    for (i, j) in edges_Nc:
-        for k in vehicles:
-            for t in periods:
-                model.addConstr(x[i, j, k, t] <= z[i, k, t], name=f"ev_i_{i}_{j}_{k}_{t}")
-                model.addConstr(x[i, j, k, t] <= z[j, k, t], name=f"ev_j_{i}_{j}_{k}_{t}")
-    # --- Valid inequalities (18)-(19): symmetry breaking for multiple vehicles ---
-    if m > 1:
-        for k in range(1, m):
-            for t in periods:
-                model.addConstr(z[0, k, t] >= z[0, k + 1, t], name=f"sym_use_{k}_{t}")
-        for j_node in Nc:
-            for k in range(1, m):
-                for t in periods:
-                    model.addConstr(
-                        gp.quicksum(2 ** (j_node - i) * z[i, k, t] for i in range(1, j_node + 1))
-                        >= gp.quicksum(2 ** (j_node - i) * z[i, k + 1, t] for i in range(1, j_node + 1)),
-                        name=f"lex_{j_node}_{k}_{t}"
-                    )
-    # --- Lazy SEC callback (constraint 11) ---
-    def find_subtours(x_val, z_val, k, t):
-        """Find customer-only subtours (not connected to depot) in solution."""
-        visited = [i for i in Nc if z_val.get((i, k, t), 0) > 0.5]
-        if len(visited) < 2:
-            return []
-        # Build adjacency among visited customers
-        adj = {i: [] for i in visited}
-        for (a, b) in edges_Nc:
-            if a in visited and b in visited:
-                val = x_val.get((a, b, k, t), 0)
-                if val > 0.5:
-                    adj[a].append(b)
-                    adj[b].append(a)
-        # Find connected components (ignoring depot)
-        seen = set()
-        components = []
-        for start in visited:
-            if start not in seen:
-                comp = []
-                stack = [start]
-                while stack:
-                    node = stack.pop()
-                    if node not in seen:
-                        seen.add(node)
-                        comp.append(node)
-                        for nb in adj.get(node, []):
-                            if nb not in seen:
-                                stack.append(nb)
-                components.append(comp)
-        # Only components not connected to depot are subtours
-        # Check depot connectivity
-        depot_neighbors = set()
-        for (a, b) in edges:
-            if a == 0 and b in visited and x_val.get((a, b, k, t), 0) > 0.5:
-                depot_neighbors.add(b)
-            elif b == 0 and a in visited and x_val.get((a, b, k, t), 0) > 0.5:
-                depot_neighbors.add(a)
-        subtours = []
-        for comp in components:
-            if not any(v in depot_neighbors for v in comp):
-                subtours.append(comp)
-        return subtours
-    def callback(model, where):
-        if where == GRB.Callback.MIPSOL:
-            x_vals = {key: model.cbGetSolution(x[key]) for key in x}
-            z_vals = {key: model.cbGetSolution(z[key]) for key in z}
-            for k in vehicles:
-                for t in periods:
-                    subtours = find_subtours(x_vals, z_vals, k, t)
-                    for comp in subtours:
-                        S = set(comp)
-                        E_S = [(a, b) for (a, b) in edges if a in S and b in S]
-                        e_node = comp[0]
-                        model.cbLazy(
-                            gp.quicksum(x[a, b, k, t] for (a, b) in E_S)
-                            <= gp.quicksum(z[i, k, t] for i in S) - z[e_node, k, t]
-                        )
-    model.optimize(callback)
-    # --- Extract and write solution ---
-    result = {"objective_value": None}
-    if model.SolCount > 0:
-        result["objective_value"] = model.ObjVal
-        result["gap"] = model.MIPGap
-        result["status"] = model.Status
-        y_sol = {str(t): round(y[t].X) for t in periods}
-        result["y"] = y_sol
-        z_sol = {}
-        for i in N:
-            for k in vehicles:
-                for t in periods:
-                    v = z[i, k, t].X
-                    if v > 0.5:
-                        z_sol[f"{i}_{k}_{t}"] = 1
-        result["z"] = z_sol
-        x_sol = {}
-        for (i, j) in edges:
-            for k in vehicles:
-                for t in periods:
-                    v = x[i, j, k, t].X
-                    if v > 0.5:
-                        x_sol[f"{i}_{j}_{k}_{t}"] = round(v)
-        result["x"] = x_sol
-    with open(solution_path, 'w') as fp:
-        json.dump(result, fp, indent=2)
-    print(f"Objective value: {result['objective_value']}")
-    return result
-def main():
-    parser = argparse.ArgumentParser(description="Solve 2-SPRP with Gurobi (2-BF formulation)")
-    parser.add_argument("--instance_path", type=str, required=True,
-                        help="Path to JSON instance file")
-    parser.add_argument("--solution_path", type=str, required=True,
-                        help="Path to write solution JSON")
-    parser.add_argument("--time_limit", type=int, default=3600,
-                        help="Solver time limit 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)
-if __name__ == "__main__":
-    main()

adulyasak2015/gurobi_feasi_result/large_feasi_result_1.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "feasible": true,
-  "violated_constraints": [],
-  "violations": [],
-  "violation_magnitudes": []
-}

adulyasak2015/gurobi_feasi_result/large_feasi_result_2.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "feasible": true,
-  "violated_constraints": [],
-  "violations": [],
-  "violation_magnitudes": []
-}

adulyasak2015/gurobi_feasi_result/large_feasi_result_3.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "feasible": true,
-  "violated_constraints": [],
-  "violations": [],
-  "violation_magnitudes": []
-}

adulyasak2015/gurobi_feasi_result/large_feasi_result_4.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "feasible": true,
-  "violated_constraints": [],
-  "violations": [],
-  "violation_magnitudes": []
-}

adulyasak2015/gurobi_feasi_result/large_feasi_result_5.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "feasible": true,
-  "violated_constraints": [],
-  "violations": [],
-  "violation_magnitudes": []
-}

adulyasak2015/gurobi_feasi_result/tiny_feasi_result.json DELETED Viewed

@@ -1,6 +0,0 @@
-{
-  "feasible": true,
-  "violated_constraints": [],
-  "violations": [],
-  "violation_magnitudes": []
-}

adulyasak2015/gurobi_solution/large_solution_1.json DELETED Viewed

@@ -1,45 +0,0 @@
-{
-  "objective_value": 24264.431698905697,
-  "gap": 0.2828023453586586,
-  "status": 9,
-  "y": {
-    "1": 1,
-    "2": 1,
-    "3": 1,
-    "4": 1,
-    "5": 1,
-    "6": 1
-  },
-  "z": {
-    "0_1_1": 1,
-    "0_1_2": 1,
-    "0_1_3": 1,
-    "0_1_4": 1,
-    "0_1_5": 1,
-    "0_1_6": 1,
-    "1_1_6": 1,
-    "6_1_6": 1,
-    "10_1_1": 1,
-    "10_1_2": 1,
-    "10_1_3": 1,
-    "12_1_5": 1,
-    "17_1_5": 1,
-    "20_1_5": 1,
-    "21_1_6": 1,
-    "28_1_4": 1
-  },
-  "x": {
-    "0_6_1_6": 1,
-    "0_10_1_1": 2,
-    "0_10_1_2": 2,
-    "0_10_1_3": 2,
-    "0_12_1_5": 1,
-    "0_17_1_5": 1,
-    "0_21_1_6": 1,
-    "0_28_1_4": 2,
-    "1_6_1_6": 1,
-    "1_21_1_6": 1,
-    "12_20_1_5": 1,
-    "17_20_1_5": 1
-  }
-}

adulyasak2015/gurobi_solution/large_solution_2.json DELETED Viewed

@@ -1,15 +0,0 @@
-{
-  "objective_value": 159840.11349897826,
-  "gap": 0.2965734591727916,
-  "status": 9,
-  "y": {
-    "1": 0,
-    "2": 0,
-    "3": 0,
-    "4": 0,
-    "5": 0,
-    "6": 0
-  },
-  "z": {},
-  "x": {}
-}

adulyasak2015/gurobi_solution/large_solution_3.json DELETED Viewed

@@ -1,15 +0,0 @@
-{
-  "objective_value": 47553.855849755346,
-  "gap": 1.0,
-  "status": 9,
-  "y": {
-    "1": 0,
-    "2": 0,
-    "3": 0,
-    "4": 0,
-    "5": 0,
-    "6": 0
-  },
-  "z": {},
-  "x": {}
-}

adulyasak2015/gurobi_solution/large_solution_4.json DELETED Viewed

@@ -1,15 +0,0 @@
-{
-  "objective_value": 24414.72888062327,
-  "gap": 1.0,
-  "status": 9,
-  "y": {
-    "1": 0,
-    "2": 0,
-    "3": 0,
-    "4": 0,
-    "5": 0,
-    "6": 0
-  },
-  "z": {},
-  "x": {}
-}

adulyasak2015/gurobi_solution/large_solution_5.json DELETED Viewed

@@ -1,15 +0,0 @@
-{
-  "objective_value": 48829.45785608655,
-  "gap": 0.3428716206683382,
-  "status": 9,
-  "y": {
-    "1": 0,
-    "2": 0,
-    "3": 0,
-    "4": 0,
-    "5": 0,
-    "6": 0
-  },
-  "z": {},
-  "x": {}
-}

adulyasak2015/gurobi_solution/tiny_solution.json DELETED Viewed

@@ -1,44 +0,0 @@
-{
-  "objective_value": 1395.7593777311158,
-  "gap": 0.0,
-  "status": 2,
-  "y": {
-    "1": 1,
-    "2": 1,
-    "3": 1
-  },
-  "z": {
-    "0_1_1": 1,
-    "0_1_2": 1,
-    "0_1_3": 1,
-    "1_1_1": 1,
-    "1_1_2": 1,
-    "2_1_1": 1,
-    "2_1_2": 1,
-    "3_1_1": 1,
-    "3_1_3": 1,
-    "4_1_1": 1,
-    "4_1_2": 1,
-    "4_1_3": 1,
-    "5_1_1": 1,
-    "5_1_2": 1,
-    "5_1_3": 1
-  },
-  "x": {
-    "0_1_1_1": 1,
-    "0_1_1_2": 1,
-    "0_3_1_3": 1,
-    "0_4_1_1": 1,
-    "0_4_1_2": 1,
-    "0_4_1_3": 1,
-    "1_2_1_2": 1,
-    "1_3_1_1": 1,
-    "2_3_1_1": 1,
-    "2_5_1_1": 1,
-    "2_5_1_2": 1,
-    "3_5_1_3": 1,
-    "4_5_1_1": 1,
-    "4_5_1_2": 1,
-    "4_5_1_3": 1
-  }
-}

adulyasak2015/gurobi_solution_log/tiny_log.jsonl DELETED Viewed

@@ -1,4 +0,0 @@
-{"time": 0.081, "objective_value": 3915.763025824631}
-{"time": 0.198, "objective_value": 1465.990467930001}
-{"time": 0.326, "objective_value": 1411.0225539300009}
-{"time": 0.655, "objective_value": 1395.9876434378402}

adulyasak2015/instance/large_instance_1.json DELETED Viewed