Nest task folders under tasks/ (part 11)

tasks/rahmaniani2020/gurobi_feasi_result/large_feasi_result_5.json

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

tasks/rahmaniani2020/gurobi_feasi_result/tiny_feasi_result.json

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

tasks/rahmaniani2020/gurobi_solution/large_solution_1.json

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

tasks/rahmaniani2020/gurobi_solution/large_solution_2.json

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

tasks/rahmaniani2020/gurobi_solution/large_solution_3.json

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

tasks/rahmaniani2020/gurobi_solution/large_solution_4.json

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

tasks/rahmaniani2020/gurobi_solution/large_solution_5.json

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

tasks/rahmaniani2020/gurobi_solution/tiny_solution.json

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

tasks/rahmaniani2020/gurobi_solution_log/large_log_1.jsonl

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

tasks/rahmaniani2020/gurobi_solution_log/large_log_2.jsonl

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

tasks/rahmaniani2020/gurobi_solution_log/large_log_3.jsonl

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

tasks/rahmaniani2020/gurobi_solution_log/large_log_4.jsonl

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

tasks/rahmaniani2020/gurobi_solution_log/large_log_5.jsonl

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

tasks/rahmaniani2020/gurobi_solution_log/tiny_log.jsonl

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

tasks/rahmaniani2020/instance/large_instance_1.json

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

tasks/rahmaniani2020/instance/large_instance_2.json

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

tasks/rahmaniani2020/instance/large_instance_3.json

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

tasks/rahmaniani2020/instance/large_instance_4.json

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

tasks/rahmaniani2020/instance/large_instance_5.json

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

tasks/rahmaniani2020/instance/tiny_instance.json

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

tasks/rahmaniani2020/instance_schema.json

@@ -0,0 +1,23 @@
+{
+  "num_facilities": "<int> Number of potential facility locations that may be opened.",
+  "num_customers": "<int> Number of customers whose demands must be served.",
+  "num_scenarios": "<int> Number of demand scenarios representing uncertainty.",
+  "total_capacity": "<int> Combined service capacity across all potential facilities.",
+  "max_total_demand": "<int> Highest aggregate customer demand among all scenarios.",
+  "facilities": {
+    "x_coordinates": "<list[float], length num_facilities> Horizontal coordinate of each potential facility on the service region grid.",
+    "y_coordinates": "<list[float], length num_facilities> Vertical coordinate of each potential facility on the service region grid.",
+    "fixed_costs": "<list[int], length num_facilities> One-time cost incurred for opening each facility.",
+    "capacities": "<list[int], length num_facilities> Maximum total flow each facility can ship to customers if opened."
+  },
+  "customers": {
+    "x_coordinates": "<list[float], length num_customers> Horizontal coordinate of each customer on the service region grid.",
+    "y_coordinates": "<list[float], length num_customers> Vertical coordinate of each customer on the service region grid."
+  },
+  "routing_costs": "<list[list[float]], shape [num_facilities][num_customers]> Per-unit cost of shipping goods from each facility to each customer.",
+  "scenarios": {
+    "num_scenarios": "<int> Number of demand scenarios representing uncertainty.",
+    "probabilities": "<list[float], length num_scenarios> Likelihood of each demand scenario occurring.",
+    "demands": "<list[list[int]], shape [num_scenarios][num_customers]> Quantity of goods each customer requires under each scenario."
+  }
+}

tasks/rahmaniani2020/mathematical_formulation.md

@@ -0,0 +1,36 @@
+# Original Formulation: Benders Dual Decomposition – Generic MILP and Stochastic Capacitated Facility Location (SFL)
+
+Rahmaniani, Ahmed, Crainic, Gendreau, Rei. “The Benders Dual Decomposition Method,” *Operations Research*, 2020.
+
+## Generic MILP (Problem (1), Section 1)
+
+The paper develops the Benders Dual Decomposition (BDD) method for a generic mixed-integer linear program of the form $$\begin{align}
+\min_{y,x}\ & f^\top y + c^\top x \tag{1a} \\
+\text{s.t.}\ & B y \ge b, \tag{1b} \\
+& W x + T y \ge h, \tag{1c} \\
+& y \in \mathbb{Z}_+^n, \quad x \in \mathbb{R}_+^m, \tag{1d}
+\end{align}$$ where $f\in\mathbb{R}^n$, $B\in\mathbb{R}^{k\times n}$, $b\in\mathbb{R}^k$, $c\in\mathbb{R}^m$, $W\in\mathbb{R}^{\ell\times m}$, $h\in\mathbb{R}^\ell$, $T\in\mathbb{R}^{\ell\times n}$. The problem is feasible and bounded.
+
+## Test Problem: Stochastic Capacitated Facility Location (SFL) (Appendix D.2)
+
+**Sets and indices:** $N$ set of potential facility sites (indexed by $i$); $M$ set of customers (indexed by $j$); $S$ set of scenarios (indexed by $s$).
+
+**Parameters:** $f_i$ fixed cost of opening facility $i$; $u_i$ capacity of facility $i$; $c_{ij}$ routing cost per unit of flow from $i$ to $j$; $p_s$ probability of scenario $s$; $d_j^s$ demand of customer $j$ in scenario $s$.
+
+**Decision variables:** $y_i\in\{0,1\}$ equals $1$ iff facility $i$ is opened (first stage); $x_{ij}^s\ge 0$ is the flow from facility $i$ to customer $j$ under scenario $s$ (second stage).
+
+**Formulation (D.4)–(D.7):** $$\begin{align}
+\text{SFL}:\quad \min\ & \sum_{i\in N} f_i\, y_i
+  + \sum_{s\in S} p_s \sum_{i\in N}\sum_{j\in M} c_{ij}\, x_{ij}^s \tag{D.4}\\
+\text{s.t.}\ & \sum_{i\in N} x_{ij}^s \ge d_j^s,
+  && \forall\, j\in M,\ s\in S \tag{D.5}\\
+& \sum_{j\in M} x_{ij}^s \le u_i\, y_i,
+  && \forall\, i\in N,\ s\in S \tag{D.6}\\
+& \sum_{i\in N} u_i\, y_i \ge \max_{s\in S}\sum_{j\in M} d_j^s \tag{D.7}\\
+& y_i \in \{0,1\},\ \ x_{ij}^s \ge 0,
+  && \forall\, i\in N,\ j\in M,\ s\in S. \notag
+\end{align}$$
+
+**Interpretation.** Objective (D.4) combines first-stage facility opening costs with expected second-stage routing costs. Constraint (D.5) enforces demand satisfaction in every scenario; (D.6) bounds flows out of each facility by its capacity (and forces no flow from closed facilities); (D.7) is the complete-recourse property, ensuring that the total opened capacity covers the worst-case total demand.
+
+Matching SFL to the generic form (1): the first-stage decisions are $y$ with $f = (f_i)_{i\in N}$ and constraint (D.7) taking the role of $By\ge b$; the second-stage recourse $x=(x_{ij}^s)$ and constraints (D.5)–(D.6) correspond to $Wx+Ty\ge h$.

tasks/rahmaniani2020/problem_description.txt

@@ -0,0 +1,7 @@
+# Problem Description
+
+A company must decide which facilities to open among a set of potential locations in order to serve a set of customers whose demands are uncertain. The uncertainty is represented by a finite set of scenarios, each occurring with a known probability. The input data specifies, for each potential facility, a fixed cost of opening, a service capacity, and geographic coordinates. For each customer, the data specifies geographic coordinates. For each facility-customer pair, a per-unit routing cost is given. For each scenario, a probability of occurrence is provided along with the demand of every customer under that scenario.
+
+The company must choose which facilities to open and, for every scenario, how much flow to ship from each open facility to each customer. The goal is to minimize the sum of two cost components: the total fixed costs of opening the selected facilities, plus the expected routing cost, where the expected routing cost is the probability-weighted sum over all scenarios of the per-unit routing costs times the flows shipped in that scenario.
+
+The following rules govern these decisions. In every scenario, each customer's total inbound flow from all facilities must be at least as large as that customer's demand under that scenario. In every scenario, each facility's total outbound flow to all customers must not exceed that facility's capacity if the facility is open, and must be zero if the facility is not open. Finally, the total capacity of all opened facilities must be at least as large as the maximum, taken over all scenarios, of the total demand of all customers in that scenario; this ensures that the opened facilities can collectively satisfy all customer demands regardless of which scenario is realized.

tasks/rahmaniani2020/solution_logger.py

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

tasks/rahmaniani2020/solution_schema.json

@@ -0,0 +1,4 @@
+{
+  "objective_value": "<float> Total expected cost, combining facility opening costs and expected routing costs across scenarios.",
+  "y": "<list[int], length num_facilities> Whether each facility is opened (1 = opened, 0 = not opened)."
+}

tasks/rahmaniani2022/feasibility_check.py

@@ -0,0 +1,798 @@
+#!/usr/bin/env python3
+"""
+Feasibility checker (Tier C variant) for the Energy Systems Planning problem.
+
+From: Jacobson et al. (2023) - "A computationally efficient Benders
+decomposition for energy systems planning problems with detailed
+operations and time-coupling constraints"
+
+Constraints 1-12 validate the submitted investment witness. Constraint 49
+substitutes the complete investment-and-operation vector into trusted offline
+model coefficients without invoking an optimizer.
+
+Constraint 49 (objective consistency): trusted fixed-investment recourse solve.
+"""
+
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+from solverless_witness import require_linked_variables, validate_complete_witness
+
+# FRONTIEROR_RELEASE_CONTRACT_V2
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('investments', 'model_variables', 'objective_value', 'storage_energy_investments', 'transmission_investments')
+_FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ('investments', 'model_variables')
+_FRONTIEROR_DERIVED_FIELD_RULES = ()
+_FRONTIEROR_CONDITIONAL_FIELD_RULES = ()
+
+
+def _frontieror_validate_solution_contract(solution):
+    """Return a structured rejection when the public solution contract is absent."""
+    violations = []
+    if not isinstance(solution, dict):
+        violations.append("solution must be a JSON object")
+    else:
+        missing = [
+            field
+            for field in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS
+            if field not in solution or solution[field] is None
+        ]
+        if missing:
+            violations.append(
+                "missing required solution field(s): " + ", ".join(missing)
+            )
+
+        for discriminator, expected_value, fields in _FRONTIEROR_CONDITIONAL_FIELD_RULES:
+            if solution.get(discriminator) != expected_value:
+                continue
+            conditional_missing = [
+                field
+                for field in fields
+                if field not in solution or solution[field] is None
+            ]
+            if conditional_missing:
+                violations.append(
+                    "missing conditionally required solution field(s): "
+                    + ", ".join(conditional_missing)
+                )
+
+        empty = [
+            field
+            for field in _FRONTIEROR_NONEMPTY_SOLUTION_FIELDS
+            if field in solution and solution[field] in (None, [], {})
+        ]
+        if empty:
+            violations.append(
+                "empty required decision witness field(s): " + ", ".join(empty)
+            )
+
+        for target, operation, source, source_key in _FRONTIEROR_DERIVED_FIELD_RULES:
+            try:
+                if operation == "assignment_key_set":
+                    reported_set = set(solution[target])
+                    expected_set = {entry[source_key] for entry in solution[source]}
+                    if reported_set != expected_set:
+                        violations.append(
+                            f"{target}={sorted(reported_set)} does not match the "
+                            f"decision-derived value {sorted(expected_set)}"
+                        )
+                    continue
+
+                reported = float(solution[target])
+                if operation == "length":
+                    expected = float(len(solution[source]))
+                elif operation == "mapping_value":
+                    expected = float(solution[source][source_key])
+                else:
+                    raise ValueError("unknown derived-field operation")
+            except (KeyError, TypeError, ValueError, OverflowError):
+                violations.append(
+                    f"cannot derive {target} from decision witness field {source}"
+                )
+                continue
+            if (
+                reported != reported
+                or expected != expected
+                or reported in (float("inf"), float("-inf"))
+                or expected in (float("inf"), float("-inf"))
+                or abs(reported - expected) > 1e-6
+            ):
+                violations.append(
+                    f"{target}={reported} does not match the decision-derived "
+                    f"value {expected}"
+                )
+
+        if "objective_value" in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS:
+            objective = solution.get("objective_value")
+            if (
+                isinstance(objective, bool)
+                or not isinstance(objective, (int, float))
+                or objective != objective
+                or objective in (float("inf"), float("-inf"))
+            ):
+                violations.append("objective_value must be a finite JSON number")
+
+    if not violations:
+        return None
+    return {
+        "feasible": False,
+        "violated_constraints": ["solution_schema"],
+        "violations": violations,
+        "violation_magnitudes": [],
+    }
+
+
+def _frontieror_write_unexpected_rejection(error):
+    """Turn malformed candidate/checker exceptions into a normal rejection."""
+    import json as _frontieror_json
+    import sys as _frontieror_sys
+
+    result_path = None
+    for index, argument in enumerate(_frontieror_sys.argv):
+        if argument == "--result_path" and index + 1 < len(_frontieror_sys.argv):
+            result_path = _frontieror_sys.argv[index + 1]
+            break
+        if argument.startswith("--result_path="):
+            result_path = argument.split("=", 1)[1]
+            break
+    if not result_path:
+        return False
+    try:
+        with open(result_path, "w") as result_handle:
+            _frontieror_json.dump(
+                {
+                    "feasible": False,
+                    "violated_constraints": ["malformed_solution"],
+                    "violations": [
+                        "checker rejected malformed candidate: "
+                        + type(error).__name__
+                        + ": "
+                        + str(error)[:500]
+                    ],
+                    "violation_magnitudes": [],
+                },
+                result_handle,
+                indent=2,
+            )
+    except Exception:
+        return False
+    return True
+
+
+def check_feasibility(instance, solution, instance_path=None):
+    """Run all checks and return the same dict shape as the original main()
+    writes to result_path. Exposed as a function so the diff-test harness
+    can call it directly (parallel to other paper's _new.py files)."""
+    inst = instance
+    sol = solution
+
+    tol = 1e-5
+    eps = 1e-5
+
+    violated_constraints = set()
+    violation_details = {}    # constraint_idx -> list of message strings
+    violation_magnitudes = []  # list of dicts
+
+    def record_violation(constraint_idx, lhs, rhs, raw_excess, msg):
+        violated_constraints.add(constraint_idx)
+        if constraint_idx not in violation_details:
+            violation_details[constraint_idx] = []
+        violation_details[constraint_idx].append(msg)
+        normalizer = max(abs(rhs), eps)
+        violation_magnitudes.append({
+            "constraint": constraint_idx,
+            "lhs": lhs,
+            "rhs": rhs,
+            "raw_excess": raw_excess,
+            "normalizer": normalizer,
+            "ratio": raw_excess / normalizer
+        })
+
+    def check_leq(constraint_idx, lhs, rhs, msg):
+        excess = lhs - rhs
+        if excess > tol:
+            record_violation(constraint_idx, lhs, rhs, excess, msg)
+
+    def check_geq(constraint_idx, lhs, rhs, msg):
+        excess = rhs - lhs
+        if excess > tol:
+            record_violation(constraint_idx, lhs, rhs, excess, msg)
+
+    def check_eq(constraint_idx, lhs, rhs, msg):
+        excess = abs(lhs - rhs)
+        if excess > tol:
+            record_violation(constraint_idx, lhs, rhs, excess, msg)
+
+    # =========================================================================
+    # Check if solution has investment data
+    # =========================================================================
+    has_investments = "investments" in sol
+
+    if not has_investments:
+        return {
+            "feasible": False,
+            "violated_constraints": ["solution_schema"],
+            "violations": ["No investment solution provided (null or missing)"],
+            "violation_magnitudes": []
+        }
+
+    # =========================================================================
+    # Extract instance data
+    # =========================================================================
+    generators = inst["generators"]
+    gen_params = inst["generator_parameters"]
+    existing_cap = inst["existing_capacity"]
+    trans_lines = inst["transmission_lines"]
+    release_convention = inst["released_investment_convention"]
+
+    num_gen = len(generators)
+    G = list(range(num_gen))
+    G_UC = [g for g in G if generators[g]["is_UC"]]
+    G_STOR = [g for g in G if generators[g]["is_storage"]]
+    G_HYDRO = [g for g in G if generators[g]["is_hydro"]]
+    G_NONRET = set(g for g in G if not generators[g]["can_retire"])
+    G_UC_set = set(G_UC)
+    G_STOR_set = set(G_STOR)
+    L = list(range(len(trans_lines)))
+
+    # Released convention: physical UC blocks and integer 1-MW non-UC blocks.
+    gamma_P = {}
+    for g in G:
+        if g in G_UC_set:
+            gamma_P[g] = generators[g]["capacity_size_MW"]
+        else:
+            gamma_P[g] = float(release_convention["non_uc_power_increment_MW"])
+
+    # gamma_E: energy_capacity_size_MWh for UC storage, 1.0 otherwise
+    gamma_E = {}
+    for g in G_STOR:
+        if g in G_UC_set:
+            rtype = generators[g]["resource_type"]
+            gamma_E[g] = gen_params[rtype]["energy_capacity_size_MWh"]
+        else:
+            gamma_E[g] = float(
+                release_convention["non_uc_storage_energy_increment_MWh"]
+            )
+
+    # Existing power capacity
+    y_P_0 = {}
+    for g in G:
+        y_P_0[g] = existing_cap.get(str(g), 0.0)
+
+    # Existing energy capacity for storage
+    y_E_0 = {}
+    for g in G_STOR:
+        rtype = generators[g]["resource_type"]
+        bp = gen_params[rtype]
+        phys_cap_size = bp.get("capacity_size_MW", 1.0)
+        e_size = bp.get("energy_capacity_size_MWh", 1.0)
+        if phys_cap_size > 0:
+            y_E_0[g] = (y_P_0[g] / phys_cap_size) * e_size
+        else:
+            y_E_0[g] = 0.0
+
+    # Max capacities
+    y_P_max = {}
+    for g in G:
+        rtype = generators[g]["resource_type"]
+        y_P_max[g] = gen_params[rtype]["max_capacity_MW"]
+
+    y_E_max = {}
+    for g in G_STOR:
+        rtype = generators[g]["resource_type"]
+        y_E_max[g] = gen_params[rtype]["max_energy_capacity_MWh"]
+
+    # Storage duration limits
+    rho_min_stor = {}
+    rho_max_stor = {}
+    for g in G_STOR:
+        rtype = generators[g]["resource_type"]
+        rho_min_stor[g] = gen_params[rtype]["min_duration_MWh_per_MW"]
+        rho_max_stor[g] = gen_params[rtype]["max_duration_MWh_per_MW"]
+
+    # =========================================================================
+    # Extract solution investment variables
+    # =========================================================================
+    inv = sol.get("investments", {})
+    stor_inv = sol.get("storage_energy_investments", {})
+    trans_inv = sol.get("transmission_investments", {})
+
+    # Power capacity variables
+    y_P_new = {}
+    y_P_ret = {}
+    y_P = {}
+    for g in G:
+        gs = str(g)
+        if gs in inv:
+            y_P_new[g] = inv[gs]["new_units"]
+            y_P_ret[g] = abs(inv[gs]["retired_units"])
+            y_P[g] = inv[gs]["total_capacity_MW"]
+        else:
+            y_P_new[g] = 0.0
+            y_P_ret[g] = 0.0
+            y_P[g] = y_P_0[g]
+
+    # Storage energy capacity variables
+    y_E_new = {}
+    y_E = {}
+    for g in G_STOR:
+        gs = str(g)
+        if gs in stor_inv:
+            y_E_new[g] = stor_inv[gs]["new_units"]
+            y_E[g] = stor_inv[gs]["total_energy_MWh"]
+        else:
+            y_E_new[g] = 0.0
+            y_E[g] = y_E_0[g]
+
+    # Derive y_E_ret from constraint (13d)
+    y_E_ret = {}
+    for g in G_STOR:
+        if gamma_E[g] > 0:
+            y_E_ret[g] = y_E_new[g] - (y_E[g] - y_E_0[g]) / gamma_E[g]
+        else:
+            y_E_ret[g] = 0.0
+
+    # Transmission capacity variables
+    y_F_new = {}
+    y_F = {}
+    for l_idx in L:
+        ls = str(l_idx)
+        if ls in trans_inv:
+            y_F_new[l_idx] = trans_inv[ls]["new_MW"]
+            y_F[l_idx] = trans_inv[ls]["total_capacity_MW"]
+        else:
+            y_F_new[l_idx] = 0.0
+            y_F[l_idx] = trans_lines[l_idx]["existing_capacity_MW"]
+
+    # MILP investment variables, including transmission expansion, are integer
+    # counts of the increments declared above.
+    if sol.get("formulation", "MILP") == "MILP":
+        integer_values = [
+            (f"y_P_new[{g}]", y_P_new[g]) for g in G
+        ] + [
+            (f"y_P_ret[{g}]", y_P_ret[g]) for g in G
+        ] + [
+            (f"y_E_new[{g}]", y_E_new[g]) for g in G_STOR
+        ] + [
+            (f"y_F_new[{line}]", y_F_new[line]) for line in L
+        ]
+        for name, value in integer_values:
+            difference = abs(float(value) - round(float(value)))
+            if difference > 1e-4:
+                record_violation(
+                    50, float(value), float(round(float(value))), difference,
+                    f"MILP investment variable {name}={value} is not integral",
+                )
+
+    # =========================================================================
+    # Check Investment Constraints (Constraints 1-12) -- unchanged from original
+    # =========================================================================
+
+    # Constraint 1 (12a)
+    for g in G:
+        lhs_val = gamma_P[g] * y_P_new[g]
+        rhs_val = y_P_max[g]
+        check_leq(1, lhs_val, rhs_val,
+                  f"Gen {g} ({generators[g]['resource_type']}): "
+                  f"gamma_P*y_P_new={lhs_val:.2f} exceeds max_cap={rhs_val:.2f}")
+
+    # Constraint 2 (12b)
+    for g in G:
+        lhs_val = gamma_P[g] * y_P_ret[g]
+        rhs_val = y_P_0[g]
+        check_leq(2, lhs_val, rhs_val,
+                  f"Gen {g} ({generators[g]['resource_type']}): "
+                  f"gamma_P*y_P_ret={lhs_val:.2f} exceeds existing_cap={rhs_val:.2f}")
+
+    # Constraint 3 (12c)
+    for g in G:
+        if g in G_NONRET:
+            lhs_val = y_P_ret[g]
+            rhs_val = 0.0
+            check_eq(3, lhs_val, rhs_val,
+                     f"Gen {g} ({generators[g]['resource_type']}): "
+                     f"non-retirable but y_P_ret={lhs_val:.6f}")
+
+    # Constraint 4 (12d)
+    for g in G:
+        lhs_val = y_P[g]
+        rhs_val = y_P_0[g] + gamma_P[g] * (y_P_new[g] - y_P_ret[g])
+        check_eq(4, lhs_val, rhs_val,
+                 f"Gen {g} ({generators[g]['resource_type']}): "
+                 f"y_P={lhs_val:.4f} != y_P_0+gamma_P*(new-ret)={rhs_val:.4f}")
+
+    # Constraint 5 (13a)
+    for g in G_STOR:
+        lhs_val = gamma_E[g] * y_E_new[g]
+        rhs_val = y_E_max[g]
+        check_leq(5, lhs_val, rhs_val,
+                  f"Storage {g}: gamma_E*y_E_new={lhs_val:.2f} exceeds "
+                  f"max_E_cap={rhs_val:.2f}")
+
+    # Constraint 6 (13b)
+    for g in G_STOR:
+        lhs_val = gamma_E[g] * y_E_ret[g]
+        rhs_val = y_E_0[g]
+        check_leq(6, lhs_val, rhs_val,
+                  f"Storage {g}: gamma_E*y_E_ret={lhs_val:.2f} exceeds "
+                  f"existing_E_cap={rhs_val:.2f}")
+
+    # Constraint 7 (13c)
+    for g in G_STOR:
+        if g in G_NONRET:
+            lhs_val = y_E_ret[g]
+            rhs_val = 0.0
+            check_eq(7, lhs_val, rhs_val,
+                     f"Storage {g}: non-retirable but y_E_ret={lhs_val:.6f}")
+
+    # Constraint 8 (13d)
+    for g in G_STOR:
+        lhs_val = y_E[g]
+        rhs_val = y_E_0[g] + gamma_E[g] * (y_E_new[g] - y_E_ret[g])
+        check_eq(8, lhs_val, rhs_val,
+                 f"Storage {g}: y_E={lhs_val:.4f} != "
+                 f"y_E_0+gamma_E*(new-ret)={rhs_val:.4f}")
+
+    # Constraint 9 (13e)
+    for g in G_STOR:
+        lhs_val = rho_min_stor[g] * y_P[g]
+        rhs_val = y_E[g]
+        check_leq(9, lhs_val, rhs_val,
+                  f"Storage {g}: rho_min*y_P={lhs_val:.2f} exceeds "
+                  f"y_E={rhs_val:.2f}")
+
+    # Constraint 10 (13f)
+    for g in G_STOR:
+        lhs_val = rho_max_stor[g] * y_P[g]
+        rhs_val = y_E[g]
+        check_geq(10, lhs_val, rhs_val,
+                  f"Storage {g}: rho_max*y_P={lhs_val:.2f} less than "
+                  f"y_E={rhs_val:.2f}")
+
+    # Constraint 11 (14a)
+    for l_idx in L:
+        lhs_val = y_F_new[l_idx]
+        rhs_val = max(
+            0.0,
+            trans_lines[l_idx]["max_capacity_MW"]
+            - trans_lines[l_idx]["existing_capacity_MW"],
+        )
+        check_leq(11, lhs_val, rhs_val,
+                  f"Line {l_idx}: y_F_new={lhs_val:.2f} exceeds "
+                  f"max_F_cap={rhs_val:.2f}")
+
+    # Constraint 12 (14b)
+    for l_idx in L:
+        lhs_val = y_F[l_idx]
+        rhs_val = trans_lines[l_idx]["existing_capacity_MW"] + y_F_new[l_idx]
+        check_eq(12, lhs_val, rhs_val,
+                 f"Line {l_idx}: y_F={lhs_val:.4f} != "
+                 f"y_F_0+y_F_new={rhs_val:.4f}")
+
+    # =========================================================================
+    # Constraints 13-48: skipped (operational variables not in solution).
+    # =========================================================================
+
+    # =========================================================================
+    # Constraint 49 (NEW): Objective-value envelope (Tier C anti-exploit)
+    #
+    # obj_lower = c^FIXED   (Eq. 29, exact from investment variables)
+    # obj_upper = obj_lower + crude upper bounds on c^VAR, c^NSE, c^START,
+    #             c^RPS, c^CO2 (loose but data-driven).
+    # =========================================================================
+    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:
+        # ------ Cost / parameter lookups (same conventions as gurobi_code.py) ------
+        def gp_val(g, key, default=0.0):
+            rtype = generators[g]["resource_type"]
+            return gen_params[rtype].get(key, default)
+
+        c_P_INV = {g: gp_val(g, "investment_cost_per_MW_yr") for g in G}
+        c_P_FOM = {g: gp_val(g, "fixed_OM_cost_per_MW_yr") for g in G}
+        c_VAR = {g: gp_val(g, "variable_cost_per_MWh") for g in G}
+        c_START = {g: gp_val(g, "start_up_cost", 0.0) for g in G_UC}
+        co2_rate = {g: gp_val(g, "CO2_emission_tons_per_MWh", 0.0) for g in G}
+
+        # Energy-side costs are explicit data, including released zeros.
+        if G_STOR and "battery" in gen_params:
+            c_E_INV_stor = {g: gen_params["battery"].get(
+                "energy_investment_cost_per_MWh_yr", 0.0) for g in G_STOR}
+        else:
+            c_E_INV_stor = {g: 0.0 for g in G_STOR}
+        c_E_FOM_stor = {
+            g: gen_params[generators[g]["resource_type"]].get(
+                "energy_fixed_OM_cost_per_MWh_yr", 0.0
+            )
+            for g in G_STOR
+        }
+        c_E_INV_hydro = {
+            g: gen_params[generators[g]["resource_type"]].get(
+                "energy_investment_cost_per_MWh_yr", 0.0
+            )
+            for g in G_HYDRO
+        }
+        c_E_FOM_hydro = {
+            g: gen_params[generators[g]["resource_type"]].get(
+                "energy_fixed_OM_cost_per_MWh_yr", 0.0
+            )
+            for g in G_HYDRO
+        }
+
+        # Transmission investment cost.
+        c_F_INV = {l_idx: trans_lines[l_idx].get("investment_cost_per_MW_yr", 0.0)
+                   for l_idx in L}
+
+        # ------ Subperiod weights and total weighted hours / demand ------
+        params = inst.get("problem_parameters", {})
+        num_weeks = params.get("num_weeks", 0)
+        delta_w = params.get("hours_per_subperiod", 168)
+        total_hours = params.get("total_hours", num_weeks * delta_w)
+        subperiod_weights = inst.get("subperiod_weights", [1.0] * num_weeks)
+
+        # alpha_t = beta_w / delta_w; sum over t = sum_w beta_w
+        if delta_w > 0:
+            total_weighted_hours = float(sum(subperiod_weights))
+        else:
+            total_weighted_hours = float(total_hours)
+
+        # Total weighted demand = sum_{w,t in H_w, z} alpha_t * d_{z,t}
+        # alpha is constant beta_w/delta_w within each subperiod; we collapse by week.
+        demand = inst.get("demand", {})
+        total_weighted_demand = 0.0
+        if delta_w > 0:
+            for z_key, dem_list in demand.items():
+                # weight every hour by its subperiod's alpha
+                for w in range(num_weeks):
+                    beta_w = subperiod_weights[w] if w < len(subperiod_weights) else 1.0
+                    alpha = beta_w / delta_w
+                    t0 = w * delta_w
+                    t1 = min((w + 1) * delta_w, len(dem_list))
+                    for t in range(t0, t1):
+                        total_weighted_demand += alpha * float(dem_list[t])
+
+        # ------ obj_lower = c^FIXED (Eq. 29, exact) ------
+        c_fixed = 0.0
+        # Investment costs: sum_g c_P_INV * gamma_P * y_P_new = c_P_INV * new_MW
+        for g in G:
+            new_mw = gamma_P[g] * float(y_P_new[g])
+            c_fixed += float(c_P_INV[g]) * new_mw
+        # Storage energy investment: sum c_E_INV * gamma_E * y_E_new
+        for g in G_STOR:
+            c_fixed += float(c_E_INV_stor[g]) * gamma_E[g] * float(y_E_new[g])
+            c_fixed += float(c_E_FOM_stor[g]) * float(y_E[g])
+        for g in G_HYDRO:
+            duration = float(gen_params[generators[g]["resource_type"]]["duration_MWh_per_MW"])
+            c_fixed += float(c_E_INV_hydro[g]) * duration * float(y_P_new[g])
+            c_fixed += float(c_E_FOM_hydro[g]) * duration * float(y_P[g])
+        # Fixed O&M: sum_g c_P_FOM * y_P
+        for g in G:
+            c_fixed += float(c_P_FOM[g]) * float(y_P[g])
+        # Transmission investment
+        for l_idx in L:
+            c_fixed += float(c_F_INV[l_idx]) * float(y_F_new[l_idx])
+
+        obj_lower = c_fixed
+
+        # ------ obj_upper = c^FIXED + crude upper bound on operational costs ------
+        # Each generator can produce at most y_P[g] MWh per hour for all hours;
+        # similarly storage withdrawals are bounded by y_P[g].
+        c_var_max = 0.0
+        for g in G:
+            c_var_max += float(c_VAR[g]) * float(y_P[g]) * total_weighted_hours
+        for g in G_STOR:
+            c_var_max += float(c_VAR[g]) * float(y_P[g]) * total_weighted_hours
+
+        # NSE upper bound: every segment's max fraction of demand, at its cost
+        c_nse_max = 0.0
+        for seg in inst.get("consumer_segments", []):
+            seg_zone = seg.get("zone")
+            seg_cost = float(seg.get("cost_per_MWh", 0.0))
+            seg_frac = float(seg.get("max_nse_fraction", 0.0))
+            if seg_cost <= 0.0 or seg_frac <= 0.0:
+                continue
+            zone_key = str(seg_zone)
+            if zone_key not in demand:
+                continue
+            dem_list = demand[zone_key]
+            zone_weighted_demand = 0.0
+            if delta_w > 0:
+                for w in range(num_weeks):
+                    beta_w = subperiod_weights[w] if w < len(subperiod_weights) else 1.0
+                    alpha = beta_w / delta_w
+                    t0 = w * delta_w
+                    t1 = min((w + 1) * delta_w, len(dem_list))
+                    for t in range(t0, t1):
+                        zone_weighted_demand += alpha * float(dem_list[t])
+            c_nse_max += seg_cost * seg_frac * zone_weighted_demand
+
+        # START upper bound: each UC unit could start every hour
+        c_start_max = 0.0
+        for g in G_UC:
+            if gamma_P[g] <= 0:
+                continue
+            num_units_bound = float(y_P[g]) / gamma_P[g]
+            c_start_max += float(c_START.get(g, 0.0)) * num_units_bound * total_weighted_hours
+
+        # RPS / CO2 noncompliance penalties (loose upper bounds)
+        policy = inst.get("policy", {})
+        c_RPS = float(policy.get("RPS_noncompliance_cost_per_MWh", 0.0) or 0.0)
+        c_CO2 = float(policy.get("CO2_noncompliance_cost_per_ton", 0.0) or 0.0)
+        # RPS noncompliance bounded by total weighted demand (full RPS shortfall)
+        c_rps_max = c_RPS * total_weighted_demand
+        # CO2 noncompliance bounded by max possible emissions (all gens at full)
+        co2_max_emissions = 0.0
+        for g in G:
+            co2_max_emissions += float(co2_rate.get(g, 0.0)) * float(y_P[g]) * total_weighted_hours
+        for g in G_STOR:
+            co2_max_emissions += float(co2_rate.get(g, 0.0)) * float(y_P[g]) * total_weighted_hours
+        c_co2_max = c_CO2 * co2_max_emissions
+
+        obj_upper = c_fixed + c_var_max + c_nse_max + c_start_max + c_rps_max + c_co2_max
+
+        # Safety floor so even an all-zero investment doesn't make obj_upper
+        # too small to catch MAX_FLOAT; tied to total demand at $1/MWh.
+        obj_upper = max(obj_upper, 1.0 + total_weighted_demand)
+
+        # ------ Compare ------
+        tol_obj_lo = max(1e-3, 1e-3 * abs(obj_lower))
+        tol_obj_hi = max(1e-3, 1e-3 * abs(obj_upper))
+
+        # NaN / Inf are always rejected.
+        if math.isnan(reported) or math.isinf(reported):
+            record_violation(
+                49, float("nan" if math.isnan(reported) else reported),
+                float(obj_upper),
+                float("inf"),
+                f"Constraint 49 (Objective consistency): reported objective_value="
+                f"{reported_obj!r} is not a finite number; "
+                f"expected value in [{obj_lower:.6g}, {obj_upper:.6g}]."
+            )
+        else:
+            shortfall = obj_lower - reported
+            overshoot = reported - obj_upper
+            if shortfall > tol_obj_lo:
+                record_violation(
+                    49, float(obj_lower), float(reported), float(shortfall),
+                    f"Constraint 49 (Objective consistency): reported objective_value="
+                    f"{reported:.6f} is below the lower bound obj_lower=c^FIXED="
+                    f"{obj_lower:.6f}; shortfall={shortfall:.6g}, tol={tol_obj_lo:.6g}"
+                )
+            if overshoot > tol_obj_hi:
+                record_violation(
+                    49, float(reported), float(obj_upper), float(overshoot),
+                    f"Constraint 49 (Objective consistency): reported objective_value="
+                    f"{reported:.6f} exceeds worst-case upper bound obj_upper="
+                    f"{obj_upper:.6f} (c^FIXED={c_fixed:.6f}, c^VAR_max={c_var_max:.6g}, "
+                    f"c^NSE_max={c_nse_max:.6g}, c^START_max={c_start_max:.6g}, "
+                    f"c^RPS_max={c_rps_max:.6g}, c^CO2_max={c_co2_max:.6g}); "
+                    f"overshoot={overshoot:.6g}, tol={tol_obj_hi:.6g}"
+                )
+
+    # The envelope above remains a cheap early screen. For an otherwise valid
+    # plan, validate the complete hourly witness by direct substitution.
+    if not violated_constraints and reported is not None and math.isfinite(reported):
+        try:
+            if instance_path is None:
+                raise ValueError("instance_path is required for solverless validation")
+            expected, witness_errors, _ = validate_complete_witness(
+                instance_path, sol, Path(__file__).resolve().parent
+            )
+            links = {}
+            investments = sol.get("investments", {})
+            for generator in range(len(inst["generators"])):
+                entry = investments.get(str(generator), {})
+                links[f"y_P_new[{generator}]"] = float(entry.get("new_units", 0.0))
+                links[f"y_P_ret[{generator}]"] = abs(float(entry.get("retired_units", 0.0)))
+                if "total_capacity_MW" in entry:
+                    links[f"y_P[{generator}]"] = float(entry["total_capacity_MW"])
+            storage = sol.get("storage_energy_investments", {})
+            for key, entry in storage.items():
+                generator = int(key)
+                links[f"y_E_new[{generator}]"] = float(entry.get("new_units", 0.0))
+                links[f"y_E[{generator}]"] = float(entry["total_energy_MWh"])
+            transmission = sol.get("transmission_investments", {})
+            for line in range(len(inst["transmission_lines"])):
+                entry = transmission.get(str(line), {})
+                links[f"y_F_new[{line}]"] = float(entry.get("new_MW", 0.0))
+                if "total_capacity_MW" in entry:
+                    links[f"y_F[{line}]"] = float(entry["total_capacity_MW"])
+            witness_errors.extend(require_linked_variables(sol, links))
+            if witness_errors or expected is None:
+                raise ValueError("; ".join(witness_errors[:20]) or "missing witness objective")
+        except Exception as error:
+            record_violation(
+                49,
+                1.0,
+                0.0,
+                1.0,
+                "Constraint 49 (Objective consistency): trusted fixed-investment "
+                f"recourse failed: {type(error).__name__}: {str(error)[:300]}",
+            )
+        else:
+            difference = abs(reported - expected)
+            objective_tol = max(1e-3, 1e-4 * max(1.0, abs(expected)))
+            if difference > objective_tol:
+                record_violation(
+                    49,
+                    reported,
+                    expected,
+                    difference,
+                    "Constraint 49 (Objective consistency): reported "
+                    f"objective_value={reported:.6f} does not equal trusted "
+                    f"fixed-investment cost={expected:.6f} "
+                    f"(difference={difference:.6g}, tol={objective_tol:.6g})",
+                )
+
+    # =========================================================================
+    # Build output (matches original feasibility_check.py shape)
+    # =========================================================================
+    sorted_violated = sorted(violated_constraints)
+    aggregated_violations = []
+    for c in sorted_violated:
+        msgs = violation_details[c]
+        if len(msgs) == 1:
+            aggregated_violations.append(msgs[0])
+        else:
+            aggregated_violations.append(
+                f"Constraint {c}: {len(msgs)} violations. "
+                f"Example: {msgs[0]}")
+
+    return {
+        "feasible": len(sorted_violated) == 0,
+        "violated_constraints": sorted_violated,
+        "violations": aggregated_violations,
+        "violation_magnitudes": violation_magnitudes
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Feasibility checker for energy systems planning solutions")
+    parser.add_argument("--instance_path", type=str, required=True)
+    parser.add_argument("--solution_path", type=str, required=True)
+    parser.add_argument("--result_path", type=str, required=True)
+    args = parser.parse_args()
+
+    with open(args.instance_path) as f:
+        inst = json.load(f)
+    with open(args.solution_path) as f:
+        sol = json.load(f)
+        _frontieror_contract_result = _frontieror_validate_solution_contract(sol)
+        if _frontieror_contract_result is not None:
+            with open(args.result_path, "w") as _frontieror_result_handle:
+                json.dump(
+                    _frontieror_contract_result,
+                    _frontieror_result_handle,
+                    indent=2,
+                )
+            return
+
+    result = check_feasibility(inst, sol, args.instance_path)
+
+    with open(args.result_path, "w") as f:
+        json.dump(result, f, indent=2)
+
+    if result["feasible"]:
+        print("Solution is FEASIBLE (investment constraints + exact recourse objective).")
+    else:
+        print(f"Solution is INFEASIBLE. Violated constraints: {result['violated_constraints']}")
+        for msg in result["violations"]:
+            print(f"  - {msg}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as _frontieror_unexpected_error:
+        if not _frontieror_write_unexpected_rejection(
+            _frontieror_unexpected_error
+        ):
+            raise

tasks/rahmaniani2022/gurobi_code.py

@@ -0,0 +1,991 @@
+"""
+Monolithic energy systems planning MILP model from Jacobson et al. (2023),
+"A computationally efficient Benders decomposition for energy systems planning
+problems with detailed operations and time-coupling constraints."
+
+Implements the full formulation (Appendix B) using Gurobi.
+"""
+
+import argparse
+import json
+import time
+import gurobipy as gp
+from gurobipy import GRB
+import os as _os, sys as _sys
+# Walk up from this file's directory to find repo root (containing scripts/).
+_GUROBI_CODE_START_TIME = time.time()
+_repo = _os.path.dirname(_os.path.abspath(__file__))
+while _repo != _os.path.dirname(_repo) and not _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _repo = _os.path.dirname(_repo)
+if _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _sys.path.insert(0, _repo)
+try:
+    from scripts.utils.gurobi_log_helper import install_gurobi_logger
+except ImportError:
+    def install_gurobi_logger(log_path):  # no-op fallback when scripts/ unavailable
+        pass
+
+
+def load_instance(path):
+    with open(path) as f:
+        return json.load(f)
+
+
+def build_model(inst, formulation="MILP", quiet=False):
+    """Build the monolithic Gurobi model from the instance data."""
+
+    m = gp.Model("energy_systems_planning")
+    m.setParam("Threads", 1)
+    if quiet:
+        m.setParam("OutputFlag", 0)
+
+    # =========================================================================
+    # Unpack instance data
+    # =========================================================================
+    params = inst["problem_parameters"]
+    policy = inst["policy"]
+    generators = inst["generators"]
+    gen_params = inst["generator_parameters"]
+    existing_cap = inst["existing_capacity"]
+    demand = inst["demand"]
+    consumer_segs = inst["consumer_segments"]
+    trans_lines = inst["transmission_lines"]
+    availability = inst["availability"]
+    hydro_inflow = inst["hydro_inflow"]
+    subperiod_weights = inst["subperiod_weights"]
+
+    num_zones = params["num_zones"]
+    num_weeks = params["num_weeks"]
+    delta_w = params["hours_per_subperiod"]  # 168
+    total_hours = params["total_hours"]
+
+    # =========================================================================
+    # Build index sets
+    # =========================================================================
+    G = list(range(len(generators)))
+    G_UC = [g for g in G if generators[g]["is_UC"]]
+    G_nonUC = [g for g in G if not generators[g]["is_UC"]]
+    G_STOR = [g for g in G if generators[g]["is_storage"]]
+    G_HYDRO = [g for g in G if generators[g]["is_hydro"]]
+    G_RPS = [g for g in G if generators[g]["is_RPS_qualifying"]]
+    G_NONRET = [g for g in G if not generators[g]["can_retire"]]
+    G_NONRET_set = set(G_NONRET)
+    G_UC_set = set(G_UC)
+    G_STOR_set = set(G_STOR)
+    G_HYDRO_set = set(G_HYDRO)
+
+    # Resources that have min output but are NOT UC, storage, or hydro
+    G_minout = [g for g in G if not generators[g]["is_UC"]
+                and not generators[g]["is_storage"]
+                and not generators[g]["is_hydro"]]
+
+    Z = list(range(num_zones))
+    W = list(range(num_weeks))
+    L = list(range(len(trans_lines)))
+
+    # G_z: generators in zone z
+    G_z = {z: [] for z in Z}
+    for g in G:
+        G_z[generators[g]["zone"]].append(g)
+
+    G_z_STOR = {z: [g for g in G_z[z] if g in G_STOR_set] for z in Z}
+
+    # Lines into / out of zone z
+    I_z_in = {z: [] for z in Z}
+    I_z_out = {z: [] for z in Z}
+    for l_idx, line in enumerate(trans_lines):
+        I_z_out[line["from_zone"]].append(l_idx)
+        I_z_in[line["to_zone"]].append(l_idx)
+
+    # Subperiod structure: H_w, t_w_0 (first), t_w (last)
+    # Hours are 0-indexed internally
+    H_w = {}
+    t_w_0 = {}
+    t_w_last = {}
+    for w in W:
+        start = w * delta_w
+        end = (w + 1) * delta_w
+        H_w[w] = list(range(start, end))
+        t_w_0[w] = start
+        t_w_last[w] = end - 1
+
+    T = list(range(total_hours))
+
+    # Map each timestep to its subperiod
+    t_to_w = {}
+    for w in W:
+        for t in H_w[w]:
+            t_to_w[t] = w
+
+    # =========================================================================
+    # Parameters
+    # =========================================================================
+
+    release_convention = inst["released_investment_convention"]
+
+    # gamma_P: released investment increment.  UC resources use their physical
+    # cluster size; non-UC resources use explicit 1-MW integer increments.
+    gamma_P = {}
+    for g in G:
+        if g in G_UC_set:
+            gamma_P[g] = generators[g]["capacity_size_MW"]
+        else:
+            gamma_P[g] = float(release_convention["non_uc_power_increment_MW"])
+
+    # gamma_E: energy capacity size for storage
+    gamma_E = {}
+    for g in G_STOR:
+        # Per math_model line 38: gamma_E_SIZE set to 1 for g not in G^UC
+        # Battery is non-UC, so gamma_E = 1.0
+        if g in G_UC_set:
+            gamma_E[g] = gen_params["battery"]["energy_capacity_size_MWh"]
+        else:
+            gamma_E[g] = float(
+                release_convention["non_uc_storage_energy_increment_MWh"]
+            )
+
+    # Existing capacities
+    y_P_0 = {}
+    for g in G:
+        y_P_0[g] = existing_cap.get(str(g), 0.0)
+
+    y_E_0 = {}
+    for g in G_STOR:
+        bp = gen_params["battery"]
+        # existing energy = (existing_MW / capacity_size_MW) * energy_capacity_size_MWh
+        if bp["capacity_size_MW"] > 0:
+            y_E_0[g] = (y_P_0[g] / bp["capacity_size_MW"]) * bp["energy_capacity_size_MWh"]
+        else:
+            y_E_0[g] = 0.0
+
+    # alpha_t = beta_w / delta_w
+    alpha = {}
+    for w in W:
+        a = subperiod_weights[w] / delta_w
+        for t in H_w[w]:
+            alpha[t] = a
+
+    # Generator type parameters
+    def gp_val(g, key, default=0.0):
+        rtype = generators[g]["resource_type"]
+        p = gen_params[rtype]
+        return p.get(key, default)
+
+    # Cost parameters
+    c_P_INV = {g: gp_val(g, "investment_cost_per_MW_yr") for g in G}
+    c_P_FOM = {g: gp_val(g, "fixed_OM_cost_per_MW_yr") for g in G}
+    c_VAR = {g: gp_val(g, "variable_cost_per_MWh") for g in G}
+    c_START = {g: gp_val(g, "start_up_cost") for g in G_UC}
+
+    c_E_INV_stor = {g: gen_params["battery"]["energy_investment_cost_per_MWh_yr"] for g in G_STOR}
+    c_E_FOM_stor = {
+        g: gen_params["battery"]["energy_fixed_OM_cost_per_MWh_yr"]
+        for g in G_STOR
+    }
+
+    # These released zero values are now explicit instance parameters.
+    c_E_INV_hydro = {
+        g: gen_params["hydro"]["energy_investment_cost_per_MWh_yr"]
+        for g in G_HYDRO
+    }
+    c_E_FOM_hydro = {
+        g: gen_params["hydro"]["energy_fixed_OM_cost_per_MWh_yr"]
+        for g in G_HYDRO
+    }
+
+    # Hydro duration rho_g
+    rho_hydro = {g: gen_params["hydro"]["duration_MWh_per_MW"] for g in G_HYDRO}
+
+    # Max capacities
+    y_P_max = {g: gp_val(g, "max_capacity_MW") for g in G}
+    y_E_max = {g: gen_params["battery"]["max_energy_capacity_MWh"] for g in G_STOR}
+
+    # Storage parameters
+    eta_charge = {g: gen_params["battery"]["charging_efficiency"] for g in G_STOR}
+    eta_discharge = {g: gen_params["battery"]["discharging_efficiency"] for g in G_STOR}
+    eta_self_discharge = {g: gen_params["battery"]["self_discharge_rate_pct"] for g in G_STOR}
+    rho_min_stor = {g: gen_params["battery"]["min_duration_MWh_per_MW"] for g in G_STOR}
+    rho_max_stor = {g: gen_params["battery"]["max_duration_MWh_per_MW"] for g in G_STOR}
+
+    # Operational parameters
+    min_output = {g: gp_val(g, "min_output_frac") for g in G}
+    ramp_up = {g: gp_val(g, "ramp_up_rate_pct_per_hr") for g in G}
+    ramp_down = {g: gp_val(g, "ramp_down_rate_pct_per_hr") for g in G}
+    min_up_time = {g: int(gp_val(g, "min_up_time_hr")) for g in G_UC}
+    min_down_time = {g: int(gp_val(g, "min_down_time_hr")) for g in G_UC}
+
+    # Availability
+    avail = {}
+    for g in G:
+        key = str(g)
+        if key in availability:
+            avail[g] = availability[key]
+        else:
+            avail[g] = [1.0] * total_hours
+
+    # Hydro inflow
+    h_inflow = {}
+    for g in G_HYDRO:
+        key = str(g)
+        if key in hydro_inflow:
+            h_inflow[g] = hydro_inflow[key]
+        else:
+            h_inflow[g] = [0.0] * total_hours
+
+    # Demand
+    d_zt = {}
+    for z in Z:
+        dem = demand[str(z)]
+        for t in T:
+            d_zt[z, t] = dem[t]
+
+    # Emissions
+    co2_rate = {g: gp_val(g, "CO2_emission_tons_per_MWh") for g in G}
+
+    # Policy
+    RPS_share = policy["RPS_share"]
+    CO2_cap_rate = policy["CO2_cap_tons_per_MWh"]
+    c_RPS = policy["RPS_noncompliance_cost_per_MWh"]
+    c_CO2 = policy["CO2_noncompliance_cost_per_ton"]
+
+    # NSE segments: list of (segment_id, zone, max_nse_fraction, cost_per_MWh)
+    # Build unique (s, z) pairs
+    nse_segments = []
+    for seg in consumer_segs:
+        nse_segments.append((seg["segment_id"], seg["zone"],
+                             seg["max_nse_fraction"], seg["cost_per_MWh"]))
+
+    # Transmission
+    y_F_0 = {l: trans_lines[l]["existing_capacity_MW"] for l in L}
+    y_F_max = {l: trans_lines[l]["max_capacity_MW"] for l in L}
+    c_F_INV = {l: trans_lines[l]["investment_cost_per_MW_yr"] for l in L}
+
+    # Determine variable type for investment
+    is_milp = (formulation == "MILP")
+    inv_vtype = GRB.INTEGER if is_milp else GRB.CONTINUOUS
+
+    # =========================================================================
+    # DECISION VARIABLES
+    # =========================================================================
+    print("Creating variables...")
+
+    # --- Investment variables ---
+    y_P_new = m.addVars(G, vtype=inv_vtype, lb=0, name="y_P_new")
+    y_P_ret = m.addVars(G, vtype=inv_vtype, lb=0, name="y_P_ret")
+    y_P = m.addVars(G, vtype=GRB.CONTINUOUS, lb=0, name="y_P")
+
+    y_E_new = m.addVars(G_STOR, vtype=inv_vtype, lb=0, name="y_E_new")
+    y_E_ret = m.addVars(G_STOR, vtype=inv_vtype, lb=0, name="y_E_ret")
+    y_E = m.addVars(G_STOR, vtype=GRB.CONTINUOUS, lb=0, name="y_E")
+
+    # Transmission expansion follows the same integer-MW MILP convention.
+    y_F_new = m.addVars(L, vtype=inv_vtype, lb=0, name="y_F_new")
+    y_F = m.addVars(L, vtype=GRB.CONTINUOUS, lb=0, name="y_F")
+
+    # --- Operational variables ---
+    # x_inj[g,t]: generation injection
+    x_inj = m.addVars(G, T, vtype=GRB.CONTINUOUS, lb=0, name="x_inj")
+
+    # x_wdw[g,t]: storage withdrawal (charging)
+    x_wdw = m.addVars(G_STOR, T, vtype=GRB.CONTINUOUS, lb=0, name="x_wdw")
+
+    # x_nse[s_idx, t]: NSE for segment index s_idx
+    nse_indices = [(i, t) for i in range(len(nse_segments)) for t in T]
+    x_nse = m.addVars(nse_indices, vtype=GRB.CONTINUOUS, lb=0, name="x_nse")
+
+    # x_soc[g,t]: state of charge (storage)
+    x_soc = m.addVars(G_STOR, T, vtype=GRB.CONTINUOUS, lb=0, name="x_soc")
+
+    # x_lvl[g,t]: reservoir level (hydro)
+    x_lvl = m.addVars(G_HYDRO, T, vtype=GRB.CONTINUOUS, lb=0, name="x_lvl")
+
+    # x_spill[g,t]: hydro spillage
+    x_spill = m.addVars(G_HYDRO, T, vtype=GRB.CONTINUOUS, lb=0, name="x_spill")
+
+    # x_flow[l,t]: transmission flow (free variable)
+    x_flow = m.addVars(L, T, vtype=GRB.CONTINUOUS, lb=-GRB.INFINITY, name="x_flow")
+
+    # UC variables (always continuous/relaxed)
+    x_commit = m.addVars(G_UC, T, vtype=GRB.CONTINUOUS, lb=0, name="x_commit")
+    x_start = m.addVars(G_UC, T, vtype=GRB.CONTINUOUS, lb=0, name="x_start")
+    x_shut = m.addVars(G_UC, T, vtype=GRB.CONTINUOUS, lb=0, name="x_shut")
+
+    # Policy slack variables
+    x_RPS = m.addVars(W, vtype=GRB.CONTINUOUS, lb=0, name="x_RPS")
+    x_CO2 = m.addVars(W, vtype=GRB.CONTINUOUS, lb=0, name="x_CO2")
+
+    m.update()
+
+    # =========================================================================
+    # OBJECTIVE FUNCTION (Eq. 29-34)
+    # =========================================================================
+    print("Building objective...")
+
+    # c^FIXED (Eq. 29)
+    c_fixed = gp.LinExpr()
+
+    # Investment costs: sum_g c_P_INV * gamma_P * y_P_new
+    for g in G:
+        c_fixed += c_P_INV[g] * gamma_P[g] * y_P_new[g]
+
+    # Storage energy investment: sum_{g in STOR} c_E_INV * gamma_E * y_E_new
+    for g in G_STOR:
+        c_fixed += c_E_INV_stor[g] * gamma_E[g] * y_E_new[g]
+
+    # Hydro energy investment: sum_{g in HYDRO} c_E_INV_hydro * rho_g * y_P_new
+    for g in G_HYDRO:
+        c_fixed += c_E_INV_hydro[g] * rho_hydro[g] * y_P_new[g]
+
+    # FOM: sum_g c_P_FOM * y_P
+    for g in G:
+        c_fixed += c_P_FOM[g] * y_P[g]
+
+    # Storage energy FOM: sum_{g in STOR} c_E_FOM * y_E
+    for g in G_STOR:
+        c_fixed += c_E_FOM_stor[g] * y_E[g]
+
+    # Hydro energy FOM: sum_{g in HYDRO} c_E_FOM_hydro * rho_g * y_P
+    for g in G_HYDRO:
+        c_fixed += c_E_FOM_hydro[g] * rho_hydro[g] * y_P[g]
+
+    # Transmission investment: sum_l c_F_INV * y_F_new
+    for l in L:
+        c_fixed += c_F_INV[l] * y_F_new[l]
+
+    # c^VAR (Eq. 30)
+    c_var = gp.LinExpr()
+    for g in G:
+        if c_VAR[g] == 0.0:
+            continue
+        for t in T:
+            c_var += c_VAR[g] * alpha[t] * x_inj[g, t]
+    for g in G_STOR:
+        if c_VAR[g] == 0.0:
+            continue
+        for t in T:
+            c_var += c_VAR[g] * alpha[t] * x_wdw[g, t]
+
+    # c^NSE (Eq. 31)
+    c_nse = gp.LinExpr()
+    for i, (sid, z, frac, cost) in enumerate(nse_segments):
+        if cost == 0.0:
+            continue
+        for t in T:
+            c_nse += cost * alpha[t] * x_nse[i, t]
+
+    # c^START (Eq. 32)
+    c_start = gp.LinExpr()
+    for g in G_UC:
+        if c_START[g] == 0.0:
+            continue
+        for t in T:
+            c_start += c_START[g] * alpha[t] * x_start[g, t]
+
+    # c^RPS + c^CO2 (Eq. 33)
+    c_policy = gp.LinExpr()
+    for w in W:
+        c_policy += c_RPS * x_RPS[w]
+        c_policy += c_CO2 * x_CO2[w]
+
+    m.setObjective(c_fixed + c_var + c_nse + c_start + c_policy, GRB.MINIMIZE)
+
+    # =========================================================================
+    # CONSTRAINTS
+    # =========================================================================
+
+    # ---- B.1 Investment Constraints ----
+    print("Adding investment constraints...")
+
+    # (12a) gamma_P * y_P_new <= y_P_max
+    for g in G:
+        m.addConstr(gamma_P[g] * y_P_new[g] <= y_P_max[g], name=f"inv_cap_{g}")
+
+    # (12b) gamma_P * y_P_ret <= y_P_0
+    for g in G:
+        m.addConstr(gamma_P[g] * y_P_ret[g] <= y_P_0[g], name=f"ret_cap_{g}")
+
+    # (12c) y_P_ret = 0 for non-retirable
+    for g in G_NONRET:
+        m.addConstr(y_P_ret[g] == 0, name=f"noret_{g}")
+
+    # (12d) y_P = y_P_0 + gamma_P * (y_P_new - y_P_ret)
+    for g in G:
+        m.addConstr(y_P[g] == y_P_0[g] + gamma_P[g] * (y_P_new[g] - y_P_ret[g]),
+                     name=f"cap_bal_{g}")
+
+    # (13a) gamma_E * y_E_new <= y_E_max
+    for g in G_STOR:
+        m.addConstr(gamma_E[g] * y_E_new[g] <= y_E_max[g], name=f"stor_inv_{g}")
+
+    # (13b) gamma_E * y_E_ret <= y_E_0
+    for g in G_STOR:
+        m.addConstr(gamma_E[g] * y_E_ret[g] <= y_E_0[g], name=f"stor_ret_{g}")
+
+    # (13c) y_E_ret = 0 for non-retirable storage
+    for g in G_STOR:
+        if g in G_NONRET_set:
+            m.addConstr(y_E_ret[g] == 0, name=f"stor_noret_{g}")
+
+    # (13d) y_E = y_E_0 + gamma_E * (y_E_new - y_E_ret)
+    for g in G_STOR:
+        m.addConstr(y_E[g] == y_E_0[g] + gamma_E[g] * (y_E_new[g] - y_E_ret[g]),
+                     name=f"stor_bal_{g}")
+
+    # (13e) rho_min * y_P <= y_E
+    for g in G_STOR:
+        m.addConstr(rho_min_stor[g] * y_P[g] <= y_E[g], name=f"stor_minrho_{g}")
+
+    # (13f) rho_max * y_P >= y_E
+    for g in G_STOR:
+        m.addConstr(rho_max_stor[g] * y_P[g] >= y_E[g], name=f"stor_maxrho_{g}")
+
+    # (14a) max_capacity_MW is total capacity after expansion.
+    for l in L:
+        m.addConstr(
+            y_F_new[l] <= max(0.0, y_F_max[l] - y_F_0[l]),
+            name=f"trans_inv_{l}",
+        )
+
+    # (14b) y_F = y_F_0 + y_F_new
+    for l in L:
+        m.addConstr(y_F[l] == y_F_0[l] + y_F_new[l], name=f"trans_bal_{l}")
+
+    # ---- B.2 Operational Constraints ----
+    print("Adding operational constraints...")
+
+    # (15) Power balance: for each zone z, timestep t
+    for z in Z:
+        for t in T:
+            lhs = gp.LinExpr()
+            # + sum_{g in G_z} x_inj
+            for g in G_z[z]:
+                lhs += x_inj[g, t]
+            # - sum_{g in G_z^STOR} x_wdw
+            for g in G_z_STOR[z]:
+                lhs -= x_wdw[g, t]
+            # - sum_{l in I_z_out} x_flow + sum_{l in I_z_in} x_flow
+            for l in I_z_out[z]:
+                lhs -= x_flow[l, t]
+            for l in I_z_in[z]:
+                lhs += x_flow[l, t]
+            # + sum_s x_nse
+            for i, (sid, sz, frac, cost) in enumerate(nse_segments):
+                if sz == z:
+                    lhs += x_nse[i, t]
+            m.addConstr(lhs == d_zt[z, t], name=f"pbal_{z}_{t}")
+
+    # (16a) x_inj <= sigma * y_P for non-UC
+    print("  Output limits...")
+    for g in G_nonUC:
+        for t in T:
+            m.addConstr(x_inj[g, t] <= avail[g][t] * y_P[g],
+                         name=f"out_lim_{g}_{t}")
+
+    # (16b) x_wdw <= sigma * y_P for storage
+    for g in G_STOR:
+        for t in T:
+            m.addConstr(x_wdw[g, t] <= avail[g][t] * y_P[g],
+                         name=f"wdw_lim_{g}_{t}")
+
+    # (16c) x_inj + x_wdw <= y_P for storage
+    for g in G_STOR:
+        for t in T:
+            m.addConstr(x_inj[g, t] + x_wdw[g, t] <= y_P[g],
+                         name=f"stor_pw_{g}_{t}")
+
+    # (16d) x_soc <= y_E
+    for g in G_STOR:
+        for t in T:
+            m.addConstr(x_soc[g, t] <= y_E[g], name=f"soc_lim_{g}_{t}")
+
+    # (16e) x_lvl <= rho * y_P for hydro
+    for g in G_HYDRO:
+        for t in T:
+            m.addConstr(x_lvl[g, t] <= rho_hydro[g] * y_P[g],
+                         name=f"lvl_lim_{g}_{t}")
+
+    # (16f) eta_charge * x_wdw <= y_E - x_soc
+    for g in G_STOR:
+        for t in T:
+            m.addConstr(eta_charge[g] * x_wdw[g, t] <= y_E[g] - x_soc[g, t],
+                         name=f"chrg_room_{g}_{t}")
+
+    # (16g) x_inj / eta_discharge <= x_soc
+    for g in G_STOR:
+        for t in T:
+            m.addConstr(x_inj[g, t] <= eta_discharge[g] * x_soc[g, t],
+                         name=f"dchrg_avail_{g}_{t}")
+
+    # (17a) x_inj >= theta * y_P for non-UC, non-storage, non-hydro
+    print("  Minimum output...")
+    for g in G_minout:
+        theta = min_output[g]
+        if theta > 0:
+            for t in T:
+                m.addConstr(x_inj[g, t] >= theta * y_P[g],
+                             name=f"min_out_{g}_{t}")
+
+    # (17b) x_inj + x_spill >= theta * y_P for hydro
+    for g in G_HYDRO:
+        theta = min_output[g]
+        if theta > 0:
+            for t in T:
+                m.addConstr(x_inj[g, t] + x_spill[g, t] >= theta * y_P[g],
+                             name=f"hydro_min_{g}_{t}")
+
+    # (18a, 18b) -y_F <= x_flow <= y_F
+    print("  Transmission limits...")
+    for l in L:
+        for t in T:
+            m.addConstr(x_flow[l, t] <= y_F[l], name=f"flow_ub_{l}_{t}")
+            m.addConstr(-x_flow[l, t] <= y_F[l], name=f"flow_lb_{l}_{t}")
+
+    # (19) x_nse <= nu_s * d_{z,t}
+    print("  NSE limits...")
+    for i, (sid, z, frac, cost) in enumerate(nse_segments):
+        for t in T:
+            m.addConstr(x_nse[i, t] <= frac * d_zt[z, t],
+                         name=f"nse_lim_{i}_{t}")
+
+    # (20a, 20b) Storage dynamics
+    print("  Storage dynamics...")
+    for g in G_STOR:
+        ec = eta_charge[g]
+        ed = eta_discharge[g]
+        sd = eta_self_discharge[g]
+        for w in W:
+            hours = H_w[w]
+            first = hours[0]
+            last = hours[-1]
+
+            # (20b) Wrap-around: first timestep links to last
+            m.addConstr(
+                x_soc[g, first] - x_soc[g, last] ==
+                ec * x_wdw[g, first] - x_inj[g, first] / ed - sd * x_soc[g, last],
+                name=f"soc_wrap_{g}_{w}")
+
+            # (20a) Interior timesteps
+            for idx in range(1, len(hours)):
+                t = hours[idx]
+                t_prev = hours[idx - 1]
+                m.addConstr(
+                    x_soc[g, t] - x_soc[g, t_prev] ==
+                    ec * x_wdw[g, t] - x_inj[g, t] / ed - sd * x_soc[g, t_prev],
+                    name=f"soc_dyn_{g}_{t}")
+
+    # (20c, 20d) Hydro dynamics
+    print("  Hydro dynamics...")
+    for g in G_HYDRO:
+        for w in W:
+            hours = H_w[w]
+            first = hours[0]
+            last = hours[-1]
+
+            # (20d) Wrap-around
+            m.addConstr(
+                x_lvl[g, first] - x_lvl[g, last] ==
+                h_inflow[g][first] * y_P[g] - x_inj[g, first] - x_spill[g, first],
+                name=f"hydro_wrap_{g}_{w}")
+
+            # (20c) Interior timesteps
+            for idx in range(1, len(hours)):
+                t = hours[idx]
+                t_prev = hours[idx - 1]
+                m.addConstr(
+                    x_lvl[g, t] - x_lvl[g, t_prev] ==
+                    h_inflow[g][t] * y_P[g] - x_inj[g, t] - x_spill[g, t],
+                    name=f"hydro_dyn_{g}_{t}")
+
+    # (21a-21d) Non-UC ramping
+    print("  Non-UC ramping...")
+    for g in G_nonUC:
+        mu_up = ramp_up[g]
+        mu_dn = ramp_down[g]
+        if mu_up == 0 and mu_dn == 0:
+            continue
+        for w in W:
+            hours = H_w[w]
+            first = hours[0]
+            last = hours[-1]
+
+            # (21c) wrap: x_inj[first] - x_inj[last] <= mu_up * y_P
+            if mu_up > 0:
+                m.addConstr(x_inj[g, first] - x_inj[g, last] <= mu_up * y_P[g],
+                             name=f"ramp_up_wrap_{g}_{w}")
+            # (21d) wrap: x_inj[last] - x_inj[first] <= mu_dn * y_P
+            if mu_dn > 0:
+                m.addConstr(x_inj[g, last] - x_inj[g, first] <= mu_dn * y_P[g],
+                             name=f"ramp_dn_wrap_{g}_{w}")
+
+            # (21a, 21b) Interior
+            for idx in range(1, len(hours)):
+                t = hours[idx]
+                t_prev = hours[idx - 1]
+                if mu_up > 0:
+                    m.addConstr(x_inj[g, t] - x_inj[g, t_prev] <= mu_up * y_P[g],
+                                 name=f"ramp_up_{g}_{t}")
+                if mu_dn > 0:
+                    m.addConstr(x_inj[g, t_prev] - x_inj[g, t] <= mu_dn * y_P[g],
+                                 name=f"ramp_dn_{g}_{t}")
+
+    # (22a-22g) UC constraints
+    print("  UC constraints...")
+    for g in G_UC:
+        gp_size = gamma_P[g]
+        theta = min_output[g]
+        for t in T:
+            # (22a) gamma * commit <= y_P
+            m.addConstr(gp_size * x_commit[g, t] <= y_P[g],
+                         name=f"uc_cap_{g}_{t}")
+            # (22b) gamma * start <= y_P
+            m.addConstr(gp_size * x_start[g, t] <= y_P[g],
+                         name=f"uc_start_cap_{g}_{t}")
+            # (22c) gamma * shut <= y_P
+            m.addConstr(gp_size * x_shut[g, t] <= y_P[g],
+                         name=f"uc_shut_cap_{g}_{t}")
+            # (22d) x_inj >= commit * theta * gamma
+            m.addConstr(x_inj[g, t] >= x_commit[g, t] * theta * gp_size,
+                         name=f"uc_min_{g}_{t}")
+            # (22e) x_inj <= commit * sigma * gamma
+            m.addConstr(x_inj[g, t] <= x_commit[g, t] * avail[g][t] * gp_size,
+                         name=f"uc_max_{g}_{t}")
+
+        # (22f, 22g) Commitment state transitions
+        for w in W:
+            hours = H_w[w]
+            first = hours[0]
+            last = hours[-1]
+
+            # (22g) Wrap-around
+            m.addConstr(
+                x_commit[g, first] - x_commit[g, last] ==
+                x_start[g, first] - x_shut[g, first],
+                name=f"uc_trans_wrap_{g}_{w}")
+
+            # (22f) Interior
+            for idx in range(1, len(hours)):
+                t = hours[idx]
+                t_prev = hours[idx - 1]
+                m.addConstr(
+                    x_commit[g, t] - x_commit[g, t_prev] ==
+                    x_start[g, t] - x_shut[g, t],
+                    name=f"uc_trans_{g}_{t}")
+
+    # (23a-23d) UC ramping
+    print("  UC ramping...")
+    for g in G_UC:
+        gp_size = gamma_P[g]
+        theta = min_output[g]
+        mu_up = ramp_up[g]
+        mu_dn = ramp_down[g]
+
+        for w in W:
+            hours = H_w[w]
+            first = hours[0]
+            last = hours[-1]
+
+            # Helper for ramp coefficients
+            def start_coeff_up(t_idx):
+                sig = avail[g][t_idx]
+                return min(sig, max(theta, mu_up))
+
+            def start_coeff_dn(t_idx):
+                sig = avail[g][t_idx]
+                return min(sig, max(theta, mu_dn))
+
+            # (23c) Wrap-around up: x_inj[first] - x_inj[last] <= ...
+            m.addConstr(
+                x_inj[g, first] - x_inj[g, last] <=
+                gp_size * mu_up * (x_commit[g, first] - x_start[g, first])
+                + gp_size * start_coeff_up(first) * x_start[g, first]
+                - gp_size * theta * x_shut[g, first],
+                name=f"uc_ramp_up_wrap_{g}_{w}")
+
+            # (23d) Wrap-around down: x_inj[last] - x_inj[first] <= ...
+            m.addConstr(
+                x_inj[g, last] - x_inj[g, first] <=
+                gp_size * mu_dn * (x_commit[g, first] - x_start[g, first])
+                + gp_size * start_coeff_dn(first) * x_start[g, first]
+                - gp_size * theta * x_shut[g, first],
+                name=f"uc_ramp_dn_wrap_{g}_{w}")
+
+            # (23a, 23b) Interior
+            for idx in range(1, len(hours)):
+                t = hours[idx]
+                t_prev = hours[idx - 1]
+
+                # (23a) Up
+                m.addConstr(
+                    x_inj[g, t] - x_inj[g, t_prev] <=
+                    gp_size * mu_up * (x_commit[g, t] - x_start[g, t])
+                    + gp_size * start_coeff_up(t) * x_start[g, t]
+                    - gp_size * theta * x_shut[g, t],
+                    name=f"uc_ramp_up_{g}_{t}")
+
+                # (23b) Down
+                m.addConstr(
+                    x_inj[g, t_prev] - x_inj[g, t] <=
+                    gp_size * mu_dn * (x_commit[g, t] - x_start[g, t])
+                    + gp_size * start_coeff_dn(t) * x_start[g, t]
+                    - gp_size * theta * x_shut[g, t],
+                    name=f"uc_ramp_dn_{g}_{t}")
+
+    # (24a, 24b, 25) Minimum up/down time
+    print("  Min up/down time...")
+    for g in G_UC:
+        gp_size = gamma_P[g]
+        tau_up = min_up_time[g]
+        tau_dn = min_down_time[g]
+
+        for w in W:
+            hours = H_w[w]
+            n_hours = len(hours)
+
+            for local_idx in range(n_hours):
+                t = hours[local_idx]
+
+                # (24a) x_commit[g,t] >= sum_{k in Omega_up(t)} x_start[g,k]
+                if tau_up > 0:
+                    lhs = gp.LinExpr()
+                    for step in range(tau_up + 1):  # 0..tau_up
+                        # phi_{w,step}(t): step steps before t (circular)
+                        k_local = (local_idx - step) % n_hours
+                        k = hours[k_local]
+                        lhs += x_start[g, k]
+                    m.addConstr(x_commit[g, t] >= lhs,
+                                 name=f"min_up_{g}_{t}")
+
+                # (24b) x_commit[g,t] + sum_{k in Omega_dn(t)} x_shut[g,k] <= y_P / gamma
+                if tau_dn > 0:
+                    lhs = x_commit[g, t]
+                    for step in range(tau_dn + 1):  # 0..tau_dn
+                        k_local = (local_idx - step) % n_hours
+                        k = hours[k_local]
+                        lhs += x_shut[g, k]
+                    m.addConstr(lhs <= y_P[g] / gp_size,
+                                 name=f"min_dn_{g}_{t}")
+
+    # ---- B.3 Policy Constraints ----
+    print("Adding policy constraints...")
+
+    # Compute total weighted demand
+    total_weighted_demand = sum(alpha[t] * d_zt[z, t] for z in Z for t in T)
+
+    # (26) RPS constraint
+    if RPS_share > 0 or c_RPS > 0:
+        rps_lhs = gp.LinExpr()
+        for w in W:
+            for t in H_w[w]:
+                for g in G_RPS:
+                    rps_lhs += alpha[t] * x_inj[g, t]
+            rps_lhs += x_RPS[w]
+        m.addConstr(rps_lhs >= RPS_share * total_weighted_demand, name="rps")
+
+    # (27a, 28) CO2 cap
+    # overline{c}^{CO2} = CO2_cap_tons_per_MWh * total_weighted_demand
+    # But for CO2 scenario, eq 28 says cap = 0.05 * total_weighted_demand
+    # The instance provides CO2_cap_tons_per_MWh which encodes this.
+    co2_cap = CO2_cap_rate * total_weighted_demand
+
+    co2_lhs = gp.LinExpr()
+    for w in W:
+        for t in H_w[w]:
+            for g in G:
+                if co2_rate[g] != 0:
+                    co2_lhs += alpha[t] * co2_rate[g] * x_inj[g, t]
+            for g in G_STOR:
+                if co2_rate[g] != 0:
+                    co2_lhs += alpha[t] * co2_rate[g] * x_wdw[g, t]
+        co2_lhs -= x_CO2[w]
+    m.addConstr(co2_lhs <= co2_cap, name="co2_cap")
+
+    if not quiet:
+        print(f"Model has {m.NumVars} variables and {m.NumConstrs} constraints.")
+    return m, {
+        "generators": generators,
+        "y_P_new": y_P_new,
+        "y_P_ret": y_P_ret,
+        "y_P": y_P,
+        "y_E_new": y_E_new,
+        "y_E_ret": y_E_ret,
+        "y_E": y_E,
+        "y_F_new": y_F_new,
+        "y_F": y_F,
+        "G": G,
+        "G_STOR": G_STOR,
+        "G_HYDRO": G_HYDRO,
+        "L": L,
+        "gamma_P": gamma_P,
+        "gamma_E": gamma_E,
+    }
+
+
+def solve_model(m, time_limit=None, formulation="MILP"):
+    """Configure solver parameters and solve."""
+
+    tol = 1e-3
+
+    # Barrier method with crossover off (for monolithic)
+    m.Params.Method = 2  # Barrier
+    m.Params.Crossover = 0  # Crossover off
+    m.Params.BarConvTol = tol
+    m.Params.OptimalityTol = tol
+    m.Params.FeasibilityTol = tol
+
+    if formulation == "MILP":
+        m.Params.MIPGap = 1e-4
+
+    if time_limit is not None:
+        m.Params.TimeLimit = time_limit
+        m.Params.MIPFocus = 1
+        m.Params.NoRelHeurTime = min(60.0, time_limit * 0.05)
+
+    print("Solving...")
+    start_time = time.time()
+    m.optimize()
+    elapsed = time.time() - start_time
+    print(f"Solve time: {elapsed:.2f} seconds")
+
+    return elapsed
+
+
+def extract_solution(m, model_data):
+    """Extract solution values and build output dict."""
+
+    sol = {}
+
+    status = m.Status
+    sol["status"] = status
+    sol["status_name"] = {
+        1: "LOADED", 2: "OPTIMAL", 3: "INFEASIBLE", 4: "INF_OR_UNBD",
+        5: "UNBOUNDED", 6: "CUTOFF", 7: "ITERATION_LIMIT",
+        8: "NODE_LIMIT", 9: "TIME_LIMIT", 10: "SOLUTION_LIMIT",
+        11: "INTERRUPTED", 12: "NUMERIC", 13: "SUBOPTIMAL",
+        14: "INPROGRESS", 15: "USER_OBJ_LIMIT", 16: "WORK_LIMIT",
+        17: "MEM_LIMIT"
+    }.get(status, "UNKNOWN")
+
+    if status in (GRB.OPTIMAL, GRB.SUBOPTIMAL, GRB.TIME_LIMIT, GRB.SOLUTION_LIMIT,
+                  GRB.ITERATION_LIMIT, GRB.NODE_LIMIT, GRB.INTERRUPTED):
+        try:
+            sol["objective_value"] = m.ObjVal
+        except Exception:
+            sol["objective_value"] = None
+    else:
+        sol["objective_value"] = None
+
+    if m.SolCount > 0:
+        try:
+            sol["objective_bound"] = m.ObjBound
+        except Exception:
+            sol["objective_bound"] = None
+
+        # Extract investment decisions
+        investments = {}
+        generators = model_data["generators"]
+        y_P_new = model_data["y_P_new"]
+        y_P_ret = model_data["y_P_ret"]
+        y_P = model_data["y_P"]
+        gamma_P = model_data["gamma_P"]
+
+        for g in model_data["G"]:
+            gen = generators[g]
+            pnew = y_P_new[g].X
+            pret = y_P_ret[g].X
+            pcap = y_P[g].X
+            if abs(pnew) > 1e-6 or abs(pret) > 1e-6:
+                investments[str(g)] = {
+                    "resource_type": gen["resource_type"],
+                    "zone": gen["zone"],
+                    "new_units": pnew,
+                    "new_MW": pnew * gamma_P[g],
+                    "retired_units": pret,
+                    "retired_MW": pret * gamma_P[g],
+                    "total_capacity_MW": pcap
+                }
+
+        sol["investments"] = investments
+
+        # Storage energy investments
+        stor_investments = {}
+        y_E_new = model_data["y_E_new"]
+        y_E = model_data["y_E"]
+        gamma_E = model_data["gamma_E"]
+        for g in model_data["G_STOR"]:
+            enew = y_E_new[g].X
+            ecap = y_E[g].X
+            if abs(enew) > 1e-6:
+                stor_investments[str(g)] = {
+                    "new_units": enew,
+                    "new_MWh": enew * gamma_E[g],
+                    "total_energy_MWh": ecap
+                }
+        sol["storage_energy_investments"] = stor_investments
+
+        # Transmission investments
+        trans_investments = {}
+        y_F_new = model_data["y_F_new"]
+        y_F = model_data["y_F"]
+        for l in model_data["L"]:
+            fnew = y_F_new[l].X
+            if abs(fnew) > 1e-6:
+                trans_investments[str(l)] = {
+                    "new_MW": fnew,
+                    "total_capacity_MW": y_F[l].X
+                }
+        sol["transmission_investments"] = trans_investments
+    else:
+        sol["investments"] = {}
+        sol["storage_energy_investments"] = {}
+        sol["transmission_investments"] = {}
+
+    return sol
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Monolithic energy systems planning model (Jacobson et al. 2023)")
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to JSON instance file")
+    parser.add_argument("--solution_path", type=str, default="gurobi_solution_1.json",
+                        help="Path for output solution JSON")
+    parser.add_argument("--time_limit", type=int, default=None,
+                        help="Solver time limit in seconds")
+    parser.add_argument("--formulation", type=str, default="MILP",
+                        choices=["LP", "MILP"],
+                        help="Formulation type (LP or MILP)")
+    parser.add_argument("--log_path", type=str, default=None, help="Path to log incumbent solutions")
+    args = parser.parse_args()
+    install_gurobi_logger(args.log_path)
+
+    print(f"Loading instance from {args.instance_path}")
+    inst = load_instance(args.instance_path)
+
+    formulation = args.formulation
+    # If instance specifies only one formulation type, use that
+    form_types = inst["problem_parameters"].get("formulation_types", ["LP", "MILP"])
+    if formulation not in form_types:
+        print(f"Warning: requested formulation {formulation} not in instance types {form_types}.")
+
+    print(f"Building {formulation} model...")
+    model, model_data = build_model(inst, formulation=formulation)
+
+    elapsed = solve_model(model, time_limit=args.time_limit, formulation=formulation)
+
+    solution = extract_solution(model, model_data)
+    solution["solve_time_seconds"] = elapsed
+    solution["formulation"] = formulation
+    solution["instance_path"] = args.instance_path
+
+    print(f"\nStatus: {solution['status_name']}")
+    if solution["objective_value"] is not None:
+        print(f"Objective value: {solution['objective_value']:.6f}")
+
+    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 __name__ == "__main__":
+    main()

tasks/rahmaniani2022/gurobi_feasi_result/large_feasi_result_1.json

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

tasks/rahmaniani2022/gurobi_feasi_result/large_feasi_result_2.json

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

tasks/rahmaniani2022/gurobi_feasi_result/large_feasi_result_3.json

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

tasks/rahmaniani2022/gurobi_feasi_result/large_feasi_result_4.json

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

tasks/rahmaniani2022/gurobi_feasi_result/large_feasi_result_5.json

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

tasks/rahmaniani2022/gurobi_feasi_result/tiny_feasi_result.json

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

tasks/rahmaniani2022/gurobi_solution/large_solution_1.json

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

tasks/rahmaniani2022/gurobi_solution/large_solution_2.json

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

tasks/rahmaniani2022/gurobi_solution/large_solution_3.json

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

tasks/rahmaniani2022/gurobi_solution/large_solution_4.json

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

tasks/rahmaniani2022/gurobi_solution/large_solution_5.json

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

tasks/rahmaniani2022/gurobi_solution/tiny_solution.json

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

tasks/rahmaniani2022/gurobi_solution_log/large_log_1.jsonl

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

tasks/rahmaniani2022/gurobi_solution_log/large_log_2.jsonl

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

tasks/rahmaniani2022/gurobi_solution_log/large_log_3.jsonl

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

tasks/rahmaniani2022/gurobi_solution_log/large_log_4.jsonl

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

tasks/rahmaniani2022/gurobi_solution_log/large_log_5.jsonl

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

tasks/rahmaniani2022/gurobi_solution_log/tiny_log.jsonl

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

tasks/rahmaniani2022/instance/large_instance_1.json

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

tasks/rahmaniani2022/instance/large_instance_2.json

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

tasks/rahmaniani2022/instance/large_instance_3.json

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

tasks/rahmaniani2022/instance/large_instance_4.json

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

tasks/rahmaniani2022/instance/large_instance_5.json

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