Nest task folders under tasks/ (part 10)

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

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

tasks/mansini2020/gurobi_solution/large_solution_2.json

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

tasks/mansini2020/gurobi_solution/large_solution_3.json

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

tasks/mansini2020/gurobi_solution/large_solution_4.json

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

tasks/mansini2020/gurobi_solution/large_solution_5.json

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

tasks/mansini2020/gurobi_solution/tiny_solution.json

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

tasks/mansini2020/gurobi_solution_log/large_log_1.jsonl

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

tasks/mansini2020/gurobi_solution_log/large_log_2.jsonl

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

tasks/mansini2020/gurobi_solution_log/large_log_3.jsonl

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

tasks/mansini2020/gurobi_solution_log/large_log_4.jsonl

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

tasks/mansini2020/gurobi_solution_log/large_log_5.jsonl

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

tasks/mansini2020/gurobi_solution_log/tiny_log.jsonl

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

tasks/mansini2020/instance/large_instance_1.json

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

tasks/mansini2020/instance/large_instance_2.json

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

tasks/mansini2020/instance/large_instance_3.json

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

tasks/mansini2020/instance/large_instance_4.json

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

tasks/mansini2020/instance/large_instance_5.json

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

tasks/mansini2020/instance/tiny_instance.json

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

tasks/mansini2020/instance_schema.json

@@ -0,0 +1,21 @@
+{
+  "parameters": {
+    "n_groups": "<int> Number of disjoint groups from which exactly one item must be selected.",
+    "m_resources": "<int> Number of shared resources, each with a limited capacity.",
+    "n_items_per_group": "<int> Number of candidate items available within each group.",
+    "n_bar_total_items": "<int> Total number of candidate items across all groups."
+  },
+  "capacities": "<list[int], length m_resources> Maximum available amount of each shared resource.",
+  "groups": [
+    {
+      "group_id": "<int> Zero-based identifier of this group.",
+      "items": [
+        {
+          "item_id": "<int> Zero-based identifier of this item within its group.",
+          "profit": "<int> Reward earned when this item is selected.",
+          "weights": "<list[int], length m_resources> Amount of each shared resource consumed by this item."
+        }
+      ]
+    }
+  ]
+}

tasks/mansini2020/mathematical_formulation.md

@@ -0,0 +1,36 @@
+# Original Formulation (Eqs. 1–4)
+
+## Sets and Indices
+
+- $\{G_1, G_2, \ldots, G_n\}$: a collection of $n$ disjoint groups (classes) of items, with $G_q \cap G_l = \emptyset$ for all $q \neq l$.
+
+- Each group $G_i$ has $n_i = |G_i|$ items, denoted by ordered pairs $(i, j)$, $i = 1,\ldots,n$, $j = 1,\ldots,n_i$.
+
+- $\tilde{N}$: set of all items, $|\tilde{N}| = \tilde{n} = \sum_{i=1}^{n} n_i$.
+
+- $k = 1,\ldots,m$: index for the $m$ resources.
+
+## Parameters
+
+- $p_{ij} \geq 0$: profit of item $(i,j) \in \tilde{N}$.
+
+- $w_{ij}^{k} \geq 0$: amount of resource $k$ required by item $(i,j)$.
+
+- $c_k \geq 0$: capacity of resource $k$, for $k=1,\ldots,m$.
+
+## Decision Variables
+
+- $x_{ij} \in \{0,1\}$ for each $(i,j) \in \tilde{N}$: 1 if item $(i,j)$ is selected, 0 otherwise.
+
+## Objective and Constraints
+
+$$\begin{align}
+\max \quad & z = \sum_{i=1}^{n} \sum_{j=1}^{n_i} p_{ij}\, x_{ij}
+  \tag{1} \\
+\text{s.t.}\quad & \sum_{i=1}^{n} \sum_{j=1}^{n_i} w_{ij}^{k}\, x_{ij} \leq c_k
+  && k = 1,\ldots,m, \tag{2} \\
+& \sum_{j=1}^{n_i} x_{ij} = 1
+  && i = 1,\ldots,n, \tag{3} \\
+& x_{ij} \in \{0,1\}
+  && (i,j) \in \tilde{N}. \tag{4}
+\end{align}$$

tasks/mansini2020/problem_description.txt

@@ -0,0 +1,5 @@
+# Problem Description
+
+A collection of items is partitioned into a number of disjoint groups. Each group contains a specified number of items, and every item belongs to exactly one group. There are also several shared resources, each with a given capacity. For every item, the input data specifies a profit and, for each resource, the amount of that resource the item consumes. All profits and resource consumptions are nonnegative, and every resource capacity is nonnegative.
+
+The task is to select exactly one item from each group so as to maximize the total profit of the selected items. The selection must respect all resource limits: for each resource, the sum of the consumptions of the selected items across all groups must not exceed that resource's capacity. Because exactly one item must be chosen per group, omitting a group entirely or picking more than one item from any single group is not allowed.

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

@@ -0,0 +1,11 @@
+{
+  "objective_value": "<float> Total profit obtained from the chosen items across all groups.",
+  "selected_items": [
+    {
+      "group_id": "<int> Identifier of the group from which an item has been picked.",
+      "item_id": "<int> Identifier of the item chosen from the corresponding group.",
+      "profit": "<int> Profit contributed by the chosen item.",
+      "weights": "<list[int], length m_resources> Amount of each resource consumed by the chosen item."
+    }
+  ]
+}

tasks/martello1999/feasibility_check.py

@@ -0,0 +1,335 @@
+"""
+Feasibility checker for the 0-1 Knapsack Problem (KP).
+Based on: Martello, Pisinger, and Toth (1999)
+
+Hard constraints (from formulation section, top to bottom):
+  Constraint 1 (1b): sum_{j=1}^{n} w_j x_j <= c
+  Constraint 2 (1c): x_j in {0, 1}, j = 1, ..., n
+  Constraint 3 (obj): reported objective_value must equal
+                      sum_{j=1}^{n} p_j x_j (Tier-C anti-exploit check)
+"""
+
+import argparse
+import json
+
+# FRONTIEROR_RELEASE_CONTRACT_V2
+_FRONTIEROR_REQUIRED_SOLUTION_FIELDS = ('objective_value', 'selected_items')
+_FRONTIEROR_NONEMPTY_SOLUTION_FIELDS = ()
+_FRONTIEROR_DERIVED_FIELD_RULES = ()
+_FRONTIEROR_CONDITIONAL_FIELD_RULES = ()
+
+
+def _frontieror_validate_solution_contract(solution):
+    """Return a structured rejection when the public solution contract is absent."""
+    violations = []
+    if not isinstance(solution, dict):
+        violations.append("solution must be a JSON object")
+    else:
+        missing = [
+            field
+            for field in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS
+            if field not in solution or solution[field] is None
+        ]
+        if missing:
+            violations.append(
+                "missing required solution field(s): " + ", ".join(missing)
+            )
+
+        for discriminator, expected_value, fields in _FRONTIEROR_CONDITIONAL_FIELD_RULES:
+            if solution.get(discriminator) != expected_value:
+                continue
+            conditional_missing = [
+                field
+                for field in fields
+                if field not in solution or solution[field] is None
+            ]
+            if conditional_missing:
+                violations.append(
+                    "missing conditionally required solution field(s): "
+                    + ", ".join(conditional_missing)
+                )
+
+        empty = [
+            field
+            for field in _FRONTIEROR_NONEMPTY_SOLUTION_FIELDS
+            if field in solution and solution[field] in (None, [], {})
+        ]
+        if empty:
+            violations.append(
+                "empty required decision witness field(s): " + ", ".join(empty)
+            )
+
+        for target, operation, source, source_key in _FRONTIEROR_DERIVED_FIELD_RULES:
+            try:
+                reported = float(solution[target])
+                if operation == "length":
+                    expected = float(len(solution[source]))
+                elif operation == "mapping_value":
+                    expected = float(solution[source][source_key])
+                else:
+                    raise ValueError("unknown derived-field operation")
+            except (KeyError, TypeError, ValueError, OverflowError):
+                violations.append(
+                    f"cannot derive {target} from decision witness field {source}"
+                )
+                continue
+            if (
+                reported != reported
+                or expected != expected
+                or reported in (float("inf"), float("-inf"))
+                or expected in (float("inf"), float("-inf"))
+                or abs(reported - expected) > 1e-6
+            ):
+                violations.append(
+                    f"{target}={reported} does not match the decision-derived "
+                    f"value {expected}"
+                )
+
+        if "objective_value" in _FRONTIEROR_REQUIRED_SOLUTION_FIELDS:
+            objective = solution.get("objective_value")
+            if (
+                isinstance(objective, bool)
+                or not isinstance(objective, (int, float))
+                or objective != objective
+                or objective in (float("inf"), float("-inf"))
+            ):
+                violations.append("objective_value must be a finite JSON number")
+
+    if not violations:
+        return None
+    return {
+        "feasible": False,
+        "violated_constraints": ["solution_schema"],
+        "violations": violations,
+        "violation_magnitudes": [],
+    }
+
+
+def _frontieror_write_unexpected_rejection(error):
+    """Turn malformed candidate/checker exceptions into a normal rejection."""
+    import json as _frontieror_json
+    import sys as _frontieror_sys
+
+    result_path = None
+    for index, argument in enumerate(_frontieror_sys.argv):
+        if argument == "--result_path" and index + 1 < len(_frontieror_sys.argv):
+            result_path = _frontieror_sys.argv[index + 1]
+            break
+        if argument.startswith("--result_path="):
+            result_path = argument.split("=", 1)[1]
+            break
+    if not result_path:
+        return False
+    try:
+        with open(result_path, "w") as result_handle:
+            _frontieror_json.dump(
+                {
+                    "feasible": False,
+                    "violated_constraints": ["malformed_solution"],
+                    "violations": [
+                        "checker rejected malformed candidate: "
+                        + type(error).__name__
+                        + ": "
+                        + str(error)[:500]
+                    ],
+                    "violation_magnitudes": [],
+                },
+                result_handle,
+                indent=2,
+            )
+    except Exception:
+        return False
+    return True
+
+
+TOL = 1e-5
+EPS = 1e-5
+
+
+def check_feasibility(instance, solution):
+    n = instance["n"]
+    capacity = instance["capacity"]
+    items = instance["items"]
+
+    # Build lookup from item id to item data
+    item_map = {item["id"]: item for item in items}
+    valid_ids = set(item_map.keys())
+
+    selected = solution.get("selected_items", [])
+
+    violated_constraints = set()
+    violations = []
+    violation_magnitudes = []
+
+    # -------------------------------------------------------------------------
+    # Constraint 2 (1c): x_j in {0, 1} — each selected item must be a valid
+    # item id, appear at most once, and be within {1, ..., n}.
+    # -------------------------------------------------------------------------
+    seen = set()
+    invalid_items = []
+    duplicate_items = []
+    for item_id in selected:
+        if item_id not in valid_ids:
+            invalid_items.append(item_id)
+        if item_id in seen:
+            duplicate_items.append(item_id)
+        seen.add(item_id)
+
+    if invalid_items:
+        violated_constraints.add(2)
+        violations.append(
+            f"Selected items not in instance: {invalid_items}"
+        )
+        for item_id in invalid_items:
+            # violation_amount = 1 per invalid item (binary domain violation)
+            violation_magnitudes.append({
+                "constraint": 2,
+                "lhs": float(item_id),
+                "rhs": 0.0,
+                "raw_excess": 1.0,
+                "normalizer": max(abs(0.0), EPS),
+                "ratio": 1.0 / max(abs(0.0), EPS),
+            })
+
+    if duplicate_items:
+        violated_constraints.add(2)
+        violations.append(
+            f"Duplicate items in selection: {duplicate_items}"
+        )
+        for item_id in duplicate_items:
+            violation_magnitudes.append({
+                "constraint": 2,
+                "lhs": 2.0,
+                "rhs": 1.0,
+                "raw_excess": 1.0,
+                "normalizer": max(abs(1.0), EPS),
+                "ratio": 1.0 / max(abs(1.0), EPS),
+            })
+
+    # -------------------------------------------------------------------------
+    # Constraint 1 (1b): sum_{j=1}^{n} w_j x_j <= c
+    # -------------------------------------------------------------------------
+    total_weight = 0.0
+    for item_id in seen:
+        if item_id in item_map:
+            total_weight += item_map[item_id]["weight"]
+
+    lhs = total_weight
+    rhs = float(capacity)
+    violation_amount = lhs - rhs  # for <= constraint: how much LHS exceeds RHS
+
+    if violation_amount > TOL:
+        violated_constraints.add(1)
+        violations.append(
+            f"Capacity exceeded: total weight {lhs} > capacity {rhs}"
+        )
+        normalizer = max(abs(rhs), EPS)
+        violation_magnitudes.append({
+            "constraint": 1,
+            "lhs": lhs,
+            "rhs": rhs,
+            "raw_excess": violation_amount,
+            "normalizer": normalizer,
+            "ratio": violation_amount / normalizer,
+        })
+
+    # -------------------------------------------------------------------------
+    # Constraint 3 (obj): reported objective_value must equal
+    # sum_{j=1}^{n} p_j x_j. Tier-C defense against LLM exploits that lie
+    # about the objective value while passing the constraint checks.
+    # -------------------------------------------------------------------------
+    reported_obj = solution.get("objective_value")
+    if reported_obj is not None:
+        try:
+            reported = float(reported_obj)
+        except (TypeError, ValueError):
+            reported = None
+        if reported is not None:
+            # Recompute over unique, valid selected items (matches weight sum)
+            true_obj = 0.0
+            for item_id in seen:
+                if item_id in item_map:
+                    true_obj += float(item_map[item_id]["profit"])
+            abs_diff = abs(reported - true_obj)
+            # Profits are positive integers; an integer mismatch by >=1 fires.
+            # Add a tiny relative slack for large magnitudes (true_obj can be
+            # ~1e10), so float round-trips never cause false positives.
+            tol = max(0.5, 1e-9 * abs(true_obj))
+            if abs_diff > tol:
+                violated_constraints.add(3)
+                violations.append(
+                    f"Objective consistency violated: reported "
+                    f"objective_value={reported} differs from recomputed "
+                    f"sum_j(p_j*x_j)={true_obj} "
+                    f"(|diff|={abs_diff:.3g}, tol={tol:.3g})"
+                )
+                normalizer = max(abs(true_obj), EPS)
+                violation_magnitudes.append({
+                    "constraint": 3,
+                    "lhs": reported,
+                    "rhs": true_obj,
+                    "raw_excess": abs_diff,
+                    "normalizer": normalizer,
+                    "ratio": abs_diff / normalizer,
+                })
+
+    # -------------------------------------------------------------------------
+    # Build result
+    # -------------------------------------------------------------------------
+    feasible = len(violated_constraints) == 0
+    result = {
+        "feasible": feasible,
+        "violated_constraints": sorted(violated_constraints),
+        "violations": violations,
+        "violation_magnitudes": violation_magnitudes,
+    }
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Feasibility checker for 0-1 Knapsack Problem "
+                    "(Martello, Pisinger, Toth 1999)"
+    )
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to the JSON instance file")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path to the JSON solution file")
+    parser.add_argument("--result_path", type=str, required=True,
+                        help="Path for the output feasibility result JSON")
+    args = parser.parse_args()
+
+    with open(args.instance_path, "r") as f:
+        instance = json.load(f)
+    with open(args.solution_path, "r") as f:
+        solution = json.load(f)
+        _frontieror_contract_result = _frontieror_validate_solution_contract(solution)
+        if _frontieror_contract_result is not None:
+            with open(args.result_path, "w") as _frontieror_result_handle:
+                json.dump(
+                    _frontieror_contract_result,
+                    _frontieror_result_handle,
+                    indent=2,
+                )
+            return
+
+    result = check_feasibility(instance, solution)
+
+    with open(args.result_path, "w") as f:
+        json.dump(result, f, indent=2)
+
+    status = "FEASIBLE" if result["feasible"] else "INFEASIBLE"
+    print(f"Result: {status}")
+    if not result["feasible"]:
+        for v in result["violations"]:
+            print(f"  - {v}")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as _frontieror_unexpected_error:
+        if not _frontieror_write_unexpected_rejection(
+            _frontieror_unexpected_error
+        ):
+            raise

tasks/martello1999/gurobi_code.py

@@ -0,0 +1,104 @@
+"""
+Gurobi implementation of the 0-1 Knapsack Problem (KP).
+Based on: Martello, Pisinger, and Toth (1999)
+"Dynamic Programming and Strong Bounds for the 0-1 Knapsack Problem"
+Management Science 45(3): 414-424
+
+Formulation (1):
+  maximize   z = sum_{j=1}^{n} p_j x_j
+  subject to sum_{j=1}^{n} w_j x_j <= c
+             x_j in {0, 1}, j = 1, ..., n
+"""
+
+import argparse
+import json
+import gurobipy as gp
+from gurobipy import GRB
+import os as _os, sys as _sys
+import time
+# Walk up from this file's directory to find repo root (containing scripts/).
+_GUROBI_CODE_START_TIME = time.time()
+_repo = _os.path.dirname(_os.path.abspath(__file__))
+while _repo != _os.path.dirname(_repo) and not _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _repo = _os.path.dirname(_repo)
+if _os.path.isdir(_os.path.join(_repo, 'scripts', 'utils')):
+    _sys.path.insert(0, _repo)
+try:
+    from scripts.utils.gurobi_log_helper import install_gurobi_logger
+except ImportError:
+    def install_gurobi_logger(log_path):  # no-op fallback when scripts/ unavailable
+        pass
+
+
+def solve_knapsack(instance_path, solution_path, time_limit):
+    # Load instance
+    with open(instance_path, "r") as f:
+        data = json.load(f)
+
+    n = data["n"]
+    capacity = data["capacity"]
+    items = data["items"]
+
+    profits = [item["profit"] for item in items]
+    weights = [item["weight"] for item in items]
+
+    # Build model
+    model = gp.Model("knapsack_01")
+    model.setParam("Threads", 1)
+    model.setParam("TimeLimit", time_limit)
+    model.setParam("OutputFlag", 1)
+
+    # Decision variables: x_j in {0, 1}
+    x = model.addVars(n, vtype=GRB.BINARY, name="x")
+
+    # Objective: maximize sum p_j * x_j
+    model.setObjective(
+        gp.quicksum(profits[j] * x[j] for j in range(n)),
+        GRB.MAXIMIZE
+    )
+
+    # Constraint: sum w_j * x_j <= c
+    model.addConstr(
+        gp.quicksum(weights[j] * x[j] for j in range(n)) <= capacity,
+        name="capacity"
+    )
+
+    # Solve
+    model.optimize()
+
+    # Extract solution
+    result = {"objective_value": None, "selected_items": []}
+
+    if model.SolCount > 0:
+        result["objective_value"] = round(model.ObjVal)
+        result["selected_items"] = [
+            items[j]["id"] for j in range(n) if x[j].X > 0.5
+        ]
+    else:
+        result["objective_value"] = 0
+        result["selected_items"] = []
+
+    # Write solution
+    with open(solution_path, "w") as f:
+        result["runtime"] = time.time() - _GUROBI_CODE_START_TIME
+        json.dump(result, f, indent=2)
+
+    print(f"Objective value: {result['objective_value']}")
+    print(f"Solution written to: {solution_path}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Solve 0-1 Knapsack Problem using Gurobi"
+    )
+    parser.add_argument("--instance_path", type=str, required=True,
+                        help="Path to the JSON instance file")
+    parser.add_argument("--solution_path", type=str, required=True,
+                        help="Path for the output solution JSON file")
+    parser.add_argument("--time_limit", type=int, required=True,
+                        help="Maximum solver runtime in seconds")
+    parser.add_argument("--log_path", type=str, default=None, help="Path to log incumbent solutions")
+    args = parser.parse_args()
+    install_gurobi_logger(args.log_path)
+
+    solve_knapsack(args.instance_path, args.solution_path, args.time_limit)

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

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

tasks/martello1999/gurobi_solution/large_solution_2.json

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

tasks/martello1999/gurobi_solution/large_solution_3.json

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

tasks/martello1999/gurobi_solution/large_solution_4.json

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

tasks/martello1999/gurobi_solution/large_solution_5.json

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

tasks/martello1999/gurobi_solution/tiny_solution.json

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

tasks/martello1999/gurobi_solution_log/large_log_1.jsonl

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

tasks/martello1999/gurobi_solution_log/large_log_2.jsonl

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

tasks/martello1999/gurobi_solution_log/large_log_3.jsonl

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

tasks/martello1999/gurobi_solution_log/large_log_4.jsonl

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

tasks/martello1999/gurobi_solution_log/large_log_5.jsonl

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

tasks/martello1999/gurobi_solution_log/tiny_log.jsonl

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

tasks/martello1999/instance/large_instance_1.json

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

tasks/martello1999/instance/large_instance_2.json

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

tasks/martello1999/instance/large_instance_3.json

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