Correct pettersson2020 objective signs and refresh validated references

RELEASE_NOTES.md

@@ -52,6 +52,8 @@ We audited the task contracts, instances, reference implementations, and solutio
 - **Canonical instance-set cleanup.** Redundant second tiny instances and their derived Gurobi artifacts were removed from `armbruster2012`, `bierwirth2017`, `borndorfer2007`, `engineer2012`, `guo2021`, `huisman2005`, `nagy2015`, `oliveira2020`, `ozturk2020`, `pecin2017`, `potthoff2010`, `ropke2009`, `rothenbacher2018`, `ruiz2007`, `segundo2019`, `spliet2015`, and `vidal2011`, leaving the canonical one tiny plus five large instances per task.
 - **Gurobi runtime and fallback consistency.** `furini2016` and `segundo2019` have repaired zero-incumbent fallback handling in the reference Gurobi programs. Runtime start-time initialization was standardized in `bode2012`, `bodur2017`, `bragin2022`, `buchheim2018`, `chen1999`, `cote2018`, `furini2021`, `garcia2011`, `hoffman1993`, `kowalczyk2018`, `kreter2018`, `letelier2022`, and `roshanaei2017`.
 
+- **Multiobjective sign and reference correction.** `pettersson2020` now maximizes input profits via equivalent negative-profit minimization, aligns its description, schemas and checker, preserves partial-frontier results on timeout, and replaces all six references; the five large references are time-limited partial frontiers, not certified complete Pareto sets, and their distinct-vector count is scored in the maximization direction.
+
 Associated reference solutions and feasibility results were regenerated or revalidated where required.
 
 

metadata/gurobi_references.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e3cf4084f24758fb9ab1bc7d5cff0a55baaa77147e9315557492c65f66764dc2
-size 31042
+oid sha256:0143258ec8dfaaa3b5220a56e5b49ee675be70e2dc87f468e501e2bd890880f3
+size 31059

metadata/paper_meta_info.json

@@ -4222,7 +4222,7 @@
     "paper_title": "Multiobjective Integer Programming: Synergistic Parallel Approaches",
     "publication": "INFORMS Journal on Computing",
     "year": 2020,
-    "direction": "min",
+    "direction": "max",
     "problem_class": "Knapsack & Selection",
     "category": "planning",
     "formulation_type": "BIP",

tasks/pettersson2020/feasibility_check.py

@@ -4,7 +4,7 @@ Feasibility checker for Multi-Objective Integer Programming (MOIP) solutions.
 Checks candidate solutions against the hard constraints from the mathematical
 formulation in Pettersson & Ozlen (2020):
 
-  min  f_1(x), ..., f_n(x)
+  min  f_1(x), ..., f_n(x), with f_k(x) = -sum_i profit[k][i]*x[i]
   s.t. Ax <= C              -- Constraint (1): Knapsack capacity
        x in Z^c             -- Constraint (2): Integrality (binary)
 
@@ -177,13 +177,38 @@ def check_feasibility(instance, solution):
     solutions = solution["solutions"]
     reported_obj_vectors = solution.get("non_dominated_objective_vectors", [])
 
+    def pareto_violation(message):
+        violated_constraints.add(4)
+        violations.append("Constraint 4 (Pareto witness) violated: " + message)
+        violation_magnitudes.append({"constraint": 4, "lhs": 1.0, "rhs": 0.0,
+                                     "raw_excess": 1.0, "normalizer": eps, "ratio": 1.0 / eps})
+
+    if not solutions:
+        # The finite binary feasible region contains x=0 and therefore has
+        # at least one nondominated vector. An empty reported frontier is not
+        # a valid solution, even though its claimed count could be zero.
+        pareto_violation("no objective vector or decision witness was returned")
+
+    positive_profits = all(all(p > 0 for p in row) for row in obj_coeffs)
+
     for sol_idx, x in enumerate(solutions):
+        if not isinstance(x, (list, tuple)) or len(x) != num_items:
+            pareto_violation(f"solution {sol_idx} must have exactly {num_items} binary entries")
+            return {"feasible": False, "violated_constraints": sorted(violated_constraints),
+                    "violations": violations, "violation_magnitudes": violation_magnitudes}
         # =====================================================================
         # Constraint (1): Ax <= C  (knapsack capacity)
         # sum(weights[i] * x[i]) <= capacity
         # =====================================================================
         lhs = sum(weights[i] * x[i] for i in range(num_items))
         rhs = capacity
+        # A positive-profit item that can still be added strictly improves
+        # every minimized negative-profit objective. In particular this
+        # rejects the formerly accepted all-zero witness on these instances.
+        if positive_profits and any(
+            x[i] == 0 and lhs + weights[i] <= capacity for i in range(num_items)
+        ):
+            pareto_violation(f"solution {sol_idx} is dominated by adding a feasible unused positive-profit item")
         violation_amount = max(0.0, lhs - rhs)
         if violation_amount > tol:
             if 1 not in violated_constraints:
@@ -247,7 +272,7 @@ def check_feasibility(instance, solution):
     #   (b) len(solutions) must equal len(non_dominated_objective_vectors).
     #   (c) For each i, k:
     #       non_dominated_objective_vectors[i][k]
-    #         == sum_j (objective_coefficients[k][j] * solutions[i][j])
+    #         == -sum_j (objective_coefficients[k][j] * solutions[i][j])
     #
     # Tolerance is 0.5 because every quantity here is integer-valued
     # (counts and sums of integer coefficients times binary variables);
@@ -339,9 +364,9 @@ def check_feasibility(instance, solution):
             binary_path = (variable_type == "binary") and all(v in (0, 1) for v in x[:min(64, len(x))])
             for k in range(num_objectives):
                 if binary_path:
-                    recomputed_k = sum(itertools.compress(obj_coeffs[k], x))
+                    recomputed_k = -sum(itertools.compress(obj_coeffs[k], x))
                 else:
-                    recomputed_k = sum(obj_coeffs[k][j] * x[j] for j in range(num_items))
+                    recomputed_k = -sum(obj_coeffs[k][j] * x[j] for j in range(num_items))
                 try:
                     claimed_k = float(claimed_vec[k])
                 except (TypeError, ValueError):
@@ -356,11 +381,28 @@ def check_feasibility(instance, solution):
                     _record_obj_violation(
                         f"solution {sol_idx} objective {k}: claimed value "
                         f"{claimed_k} differs from recomputed "
-                        f"sum_j(obj_coeffs[{k}][j]*x[j])={recomputed_k} "
+                        f"-sum_j(obj_coeffs[{k}][j]*x[j])={recomputed_k} "
                         f"(|diff|={diff})",
                         claimed_k, float(recomputed_k), diff,
                     )
 
+    # Counts refer to distinct objective vectors, not duplicate witnesses.
+    # With minimization, a lexicographically later vector cannot dominate an
+    # earlier distinct vector, so only compare each vector to its predecessors.
+    if n_vecs and all(isinstance(v, (list, tuple)) and len(v) == num_objectives
+                      and all(isinstance(c, (int, float)) and c == c and abs(c) != float('inf') for c in v)
+                      for v in reported_obj_vectors):
+        seen = set()
+        skyline = []
+        for vector in sorted(tuple(v) for v in reported_obj_vectors):
+            if vector in seen:
+                pareto_violation("duplicate objective vectors must not increase objective_value")
+            elif any(all(a <= b for a, b in zip(prev, vector)) for prev in skyline):
+                pareto_violation("a reported objective vector is dominated by another reported vector")
+            else:
+                skyline.append(vector)
+            seen.add(vector)
+
     violated_list = sorted(violated_constraints)
     feasible = len(violated_list) == 0
 

tasks/pettersson2020/gurobi_code.py

@@ -32,7 +32,13 @@ except ImportError:
 
 def load_instance(path):
     with open(path, 'r') as f:
-        return json.load(f)
+        instance = json.load(f)
+    # Public coefficients are positive profits. AIRA uses minimization, so
+    # every objective and epsilon bound must use their NEGATIVES consistently.
+    instance["objective_coefficients"] = [
+        [-profit for profit in row] for row in instance["objective_coefficients"]
+    ]
+    return instance
 
 
 def build_base_model(instance):
@@ -78,14 +84,18 @@ def solve_single_objective_ip(instance, obj_index, upper_bounds, perm, time_limi
     model.setParam("TimeLimit", max(1, time_limit_remaining))
     model.setParam("Threads", 1)
 
-    # Set objective: minimize f_{perm[0]}
-    # Since this is a knapsack where we MINIMIZE, and the paper says minimize,
-    # we minimize the sum of selected item coefficients.
-    primary_obj = perm[obj_index]
-    model.setObjective(
-        gp.quicksum(obj_coeffs[primary_obj][i] * x[i] for i in range(n_items)),
-        GRB.MINIMIZE
-    )
+    # OIP's single-free-objective leaf needs lexicographic tie-breaking on
+    # the remaining objectives; otherwise an arbitrary primary optimum can
+    # itself be dominated and the Pareto enumeration can miss vectors.
+    # load_instance already converted positive profits to negative costs.
+    model.ModelSense = GRB.MINIMIZE
+    order = [perm[obj_index]] + [j for j in perm if j != perm[obj_index]]
+    for rank, objective in enumerate(order):
+        model.setObjectiveN(
+            gp.quicksum(obj_coeffs[objective][i] * x[i] for i in range(n_items)),
+            index=rank, priority=n_obj-rank, abstol=0.0, reltol=0.0,
+            name=f"negative_profit_{objective}",
+        )
 
     # Add upper bound constraints for constrained objectives
     for idx in range(n_obj):
@@ -117,6 +127,12 @@ def is_dominated(obj_a, obj_b):
 
 
 def filter_dominated(nd_set):
+    # The contract counts distinct objective vectors, not alternative item
+    # selections giving the same vector.
+    unique = {}
+    for solution in nd_set:
+        unique.setdefault(tuple(solution["obj_vals"]), solution)
+    nd_set = list(unique.values())
     """Remove dominated solutions from the set."""
     filtered = []
     for i, sol_i in enumerate(nd_set):
@@ -184,13 +200,14 @@ def aira_worker(instance, perm, k, upper_bounds, start_time, time_limit, prev_so
     Y = aira_worker(instance, perm, k - 1, sub_bounds, start_time, time_limit, prev_sol)
 
     while len(Y) > 0:
+        # A recursive child may return its accumulated frontier just after
+        # the deadline. Preserve those witnesses BEFORE the time guard;
+        # otherwise upper levels silently turn a nonempty frontier into [].
+        nd_k.extend(Y)
         elapsed = time.time() - start_time
         if elapsed >= time_limit:
             break
 
-        # Step 4a: Collect solutions
-        nd_k.extend(Y)
-
         # Step 4b: Update bound on f_{s(k)}
         # a_{s(k)} = max{f_{s(k)}(x) | x in Y} - 1
         # We subtract 1 because variables are integer, so we need strictly less

tasks/pettersson2020/gurobi_solution/large_solution_1.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8017e8bbea90b0f06e8f45ed9b3be1bcc4438722874e7c7def9c5b6a3fc79a9f
-size 90000268
+oid sha256:906d84017e5d60d253c1e524445909f90649d6d6746253f8d975b4dcc30e190c
+size 1440001476

tasks/pettersson2020/gurobi_solution/large_solution_2.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cb8ad31e967b30425ad190cef3073925b0983f7251f45170844d351683ae0cbb
-size 90000267
+oid sha256:e8d058f93782e329ab051a5cf0ea8342441b17d18148b2cd44d641bec5e601d4
+size 1440001477

tasks/pettersson2020/gurobi_solution/large_solution_3.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a28369275cd2ceb2ed184467db99aaa55dc63b3a5367076cca57a499159d3bad
-size 90000267
+oid sha256:0f9b89899bdbb1bc14848c74545c8e65fd77063522f7bf4e8056747a539d8ed9
+size 900001009

tasks/pettersson2020/gurobi_solution/large_solution_4.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fd1ae045d7caf8f8bde8eade15af53c14bdae48c68d2a44331b27f1694da7ee7
-size 90000267
+oid sha256:ec4da40840e6f6b6dbca7db42d141528a0b44967739928f5597f563c501d70f6
+size 1980001945

tasks/pettersson2020/gurobi_solution/large_solution_5.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0556724ac06f8b829118f9d7ecd972cd10f29d49e31fd04bb5aa1e75fa414fae
-size 90000266
+oid sha256:451c22b878174cd7f7eef0a8586663d49e2114739ffa6289cf7154893156f058
+size 1440001476

tasks/pettersson2020/gurobi_solution/tiny_solution.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a4cdf20bed380aa20f677a4c2599f3ded26aa219b04c7ba3f01b118fa0c91d9e
-size 457
+oid sha256:6df3eb684824ee30fc85a6191b5c2a7c3f64db0b4110ba9590b7f579defb03ec
+size 2750

tasks/pettersson2020/gurobi_solution_log/large_log_1.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:00a576fb0fec42a32d5dbc34c78aeb421eed8e81c4e0f2d082cac3c866a87e98
-size 41
+oid sha256:9c55a41150be6337e4ec0caffeb61bf948f945ee13647f6c07897bb4549ff465
+size 51

tasks/pettersson2020/gurobi_solution_log/large_log_2.jsonl

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

tasks/pettersson2020/gurobi_solution_log/large_log_3.jsonl

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

tasks/pettersson2020/gurobi_solution_log/large_log_4.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9dfe16a48d2cef90f2006044128907a3efabcc1ba746ebfb9cc3b4d90fa6df64
-size 41
+oid sha256:bdc49b8549152e0fe609f414df508de50b6156bd55b7eb2847cc4441999feb07
+size 52

tasks/pettersson2020/gurobi_solution_log/large_log_5.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e467b787bf30a0c6651d3073e45423ad94ef383db7b0a041a47a8edd23d62578
-size 41
+oid sha256:89988362aa147a6943640126e910f80b11ab1bc545f1b566296ba35243927a90
+size 52

tasks/pettersson2020/gurobi_solution_log/tiny_log.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9d2957ef530f44294d0e0d42db45190aeef0814d3c44921e7182d06ddae728a4
-size 40
+oid sha256:c3b09f0d6d12a07eb263d0bf6e96f909e119ce43ff00bdb13e3f389bc32451a8
+size 52

tasks/pettersson2020/instance_schema.json

@@ -1,7 +1,7 @@
 {
   "num_items": "<int> Number of items available for selection.",
-  "num_objectives": "<int> Number of objectives to be simultaneously minimized.",
+  "num_objectives": "<int> Number of profit objectives to be simultaneously maximized, represented as negative-profit minimization objectives in the output.",
   "weights": "<list[int], length num_items> Weight of each item.",
   "capacity": "<int> Maximum total weight the knapsack can hold.",
-  "objective_coefficients": "<list[list[int]], shape [num_objectives][num_items]> Contribution of each item to each objective when selected."
-}
+  "objective_coefficients": "<list[list[int]], shape [num_objectives][num_items]> Positive profit magnitudes. Report objective vector component k as -sum_i objective_coefficients[k][i]*x_i; do not minimize the positive sums."
+}

tasks/pettersson2020/mathematical_formulation.md

@@ -33,3 +33,7 @@ A feasible objective vector $(z_1,\ldots,z_n)$ is *dominated* by $(z'_1,\ldots,z
 For the 0-1 multi-objective knapsack instances of Section 4.2, (3) is replaced by $$\begin{align}
 & \mathbf{x} \in \{0,1\}^c. \tag{3'}
 \end{align}$$ All $f_\ell(\mathbf{x}) = -\mathbf{p}_\ell^{\top}\mathbf{x}$ are linear (equivalently, maximizing profits), and the single linear constraint $A\mathbf{x}\le C$ is the capacity constraint $\sum_{i=1}^{c} w_i x_i \le W$.
+
+## Released JSON sign convention
+
+`objective_coefficients[k][i]` stores the positive profit $p_{ki}$, not the signed minimization coefficient. Report each component of `non_dominated_objective_vectors` as $-\sum_i p_{ki}x_i$. Dominance therefore uses componentwise minimization on these negative-profit vectors. `objective_value` is the count of distinct reported non-dominated vectors, not a scalar profit. The instance data itself is not negated or regenerated.

tasks/pettersson2020/problem_description.txt

@@ -1,7 +1,7 @@
 # Problem Description
 
-A collection of items is available for selection, where each item either is or is not included. The number of items and the number of objectives are given as input. Each item has a known integer weight, and there is a single knapsack with a known integer capacity. Each objective is defined by a vector of integer coefficients, one per item, and the value of that objective for a given selection equals the sum of the coefficients of the selected items. The total weight of all selected items must not exceed the knapsack capacity.
+A collection of items is available for selection, where each item either is or is not included. The number of items and the number of objectives are given as input. Each item has a known integer weight, and there is a single knapsack with a known integer capacity. Each objective has a positive integer profit coefficient for every item. For a selection x, its profit in objective k is the sum of the selected profit coefficients. The total weight of all selected items must not exceed the knapsack capacity.
 
-All objectives are to be simultaneously minimized. Because the objectives generally conflict, no single selection of items will minimize every objective at once. Instead, the goal is to identify the complete set of non-dominated objective vectors. An objective vector is the tuple of objective values produced by a particular selection of items. One objective vector dominates another if it is at least as good (no greater) on every objective and strictly better (strictly less) on at least one objective. A non-dominated objective vector is one that is not dominated by any other achievable objective vector. The task is to enumerate every non-dominated objective vector, along with a corresponding item selection that satisfies the capacity limit and produces it.
+All profits are to be simultaneously maximized. Equivalently, minimize the negative-profit objectives f_k(x) = -sum_i objective_coefficients[k][i] * x_i. To keep a single minimization convention, all reported non_dominated_objective_vectors must contain these NEGATIVE profit sums, not the positive profits. One such vector dominates another if it is no greater in every component and strictly less in at least one component. The goal is to enumerate the complete set of distinct non-dominated negative-profit objective vectors, with one feasible item selection for each vector. The top-level objective_value is the number of distinct vectors reported, not a profit sum. Maximizing positive profits and minimizing their negatives describe the same Pareto decisions; minimizing positive profits does not.
 
 The input data for an instance specifies the number of items, the number of objectives, the integer weight of each item, the integer knapsack capacity, and for each objective the integer coefficient associated with every item. Weights and coefficients are drawn from the range sixty through one hundred inclusive, and the capacity equals the integer part of half the sum of all item weights.

tasks/pettersson2020/solution_schema.json

@@ -1,5 +1,5 @@
 {
-  "objective_value": "<int> Total number of non-dominated objective vectors found.",
-  "non_dominated_objective_vectors": "<list[list[int]], shape [objective_value][num_objectives]> Objective values achieved by each non-dominated item selection.",
+  "objective_value": "<int> Total number of distinct non-dominated negative-profit objective vectors found; this is a count, not a profit sum.",
+  "non_dominated_objective_vectors": "<list[list[int]], shape [objective_value][num_objectives]> NEGATIVE profit sums: component k equals -sum_i objective_coefficients[k][i]*solutions[row][i]. All components are minimized, equivalently maximizing the input profits.",
   "solutions": "<list[list[int]], shape [objective_value][num_items]> Item selections corresponding to each non-dominated objective vector (1 = included, 0 = excluded)."
-}
+}