Switching to PuLP

Author: Simon-Rey

preflibtools/__init__.py

@@ -1,3 +1,3 @@
 __author__ = "Simon Rey"
 __email__ = "reysimon@orange.fr"
-__version__ = "2.0.32"
+__version__ = "2.0.33"

preflibtools/properties/subdomains/ordinal/euclidean.py

@@ -4,13 +4,13 @@
 
 from __future__ import annotations
 
+from pulp import LpVariable, LpMinimize, LpProblem, lpSum, PULP_CBC_CMD, LpStatusOptimal, LpStatusNotSolved, value
+
 from preflibtools.instances import OrdinalInstance
 from preflibtools.properties.subdomains.ordinal.singlecrossing import is_single_crossing
 
 import itertools
 
-from mip import Model, CONTINUOUS, minimize, xsum, OptimizationStatus
-
 
 def _append_to_axis(axis: list, a: int, b: int):
     """Adds alternatives a and b to the axis in such a way that a is to the
@@ -59,7 +59,7 @@ def _restrict_preferences(instance: OrdinalInstance, C_set_plus: set):
 
 def _one_euclidean_solve_lp(preferences: list, axis: list):
     """Attempts to solve the linear program for the 1-Euclidean domain,
-    given the preferences and the axis. Makes use of the MIP library.
+    given the preferences and the axis. Makes use of the PuLP library.
 
     Args:
         preferences (list): the preferences of the voters
@@ -79,69 +79,57 @@ def _one_euclidean_solve_lp(preferences: list, axis: list):
     n = len(preferences)
     m = len(axis)
 
-    model = Model()
+    model = LpProblem("1Euclidean-Model", LpMinimize)
 
-    # add variables for the voters and alternatives
-    all_vars = [model.add_var(var_type=CONTINUOUS, name=f"voter_{i}") for i in range(n)]
-    all_vars += [
-        model.add_var(var_type=CONTINUOUS, name=f"alternative_{axis[i]}")
-        for i in range(m)
-    ]
+    # Variables: voter positions (continuous)
+    voter_vars = [LpVariable(f"voter_{i}", cat="Continuous") for i in range(n)]
 
-    # TODO: var for axis.index(pair[0]) etc.
+    # Variables: alternative positions (continuous), ordered by axis
+    alt_vars = {
+        alt_id: LpVariable(f"alternative_{alt_id}", cat="Continuous")
+        for alt_id in axis
+    }
+
+    # Bounding the vars
+    model += alt_vars[axis[0]] == 0
+    for v in alt_vars.values():
+        model += v >= 0
+        model += v <= max(n, m) + 2
+    for v in voter_vars:
+        model += v >= 0
+        model += v <= max(n, m) + 2
 
     for pair in pairs:
-        # add axis constraints
-        # print("pair:", pair)
-        # model += vars[n + pair[0] - 1] + 1 <= vars[n + pair[1] - 1]
-        # print("n + axis.index(pair[0]) - 1: ", n + axis.index(pair[0]) - 1)
-        # print("n + axis.index(pair[1]) - 1: ", n + axis.index(pair[1]) - 1)
-        # print("vars[n + axis.index(pair[1]) - 1]: ", vars[n + axis.index(pair[1]) - 1])
-        model += (
-            all_vars[n + axis.index(pair[0])] + 1 <= all_vars[n + axis.index(pair[1])]
-        )
+        a, b = pair
+        # Constraint: alt_vars[a] + 1 <= alt_vars[b]
+        model += alt_vars[a] + 1 <= alt_vars[b]
+
         # add voter constraints
         for i in range(n):
-            # if voter prefers a to b
-            if preferences[i].index(pair[0]) < preferences[i].index(pair[1]):
-                # model += vars[i] + 1 <= (vars[n + pair[0] - 1] + vars[n + pair[1] - 1]) / 2
+            voter_pref = preferences[i]
+            if voter_pref.index(a) < voter_pref.index(b):
+                # voter i prefers a to b
                 model += (
-                    all_vars[i] + 1
-                    <= (
-                        all_vars[n + axis.index(pair[0])]
-                        + all_vars[n + axis.index(pair[1])]
-                    )
-                    / 2
+                        voter_vars[i] + 1
+                        <= (alt_vars[a] + alt_vars[b]) / 2
                 )
             else:
-                # model += vars[i] >= (vars[n + pair[1] - 1] + vars[n + pair[0] - 1]) / 2 + 1
+                # voter i prefers b to a
                 model += (
-                    all_vars[i]
-                    >= (
-                        all_vars[n + axis.index(pair[1])]
-                        + all_vars[n + axis.index(pair[0])]
-                    )
-                    / 2
-                    + 1
+                        voter_vars[i]
+                        >= (alt_vars[a] + alt_vars[b]) / 2 + 1
                 )
 
-    model.objective = minimize(xsum(all_vars))
-
-    # suppress log
-    model.verbose = 0
-
-    status = model.optimize()
+    # Objective: minimize sum of all variables (voter + alt positions)
+    model += lpSum(voter_vars + list(alt_vars.values()))
 
-    if status == OptimizationStatus.OPTIMAL or status == OptimizationStatus.FEASIBLE:
-        alternatives = dict()
-        for i in range(m):
-            alternatives[axis[i]] = all_vars[n + i].x
-
-        voters = []
-        for i in range(n):
-            voters.append(all_vars[i].x)
+    # Solve the model
+    model.solve(PULP_CBC_CMD(msg=False))
 
-        return status, voters, alternatives
+    if model.status in [LpStatusOptimal, LpStatusNotSolved]:
+        alternatives = {alt_id: value(var) for alt_id, var in alt_vars.items()}
+        voters = [value(var) for var in voter_vars]
+        return model.status, voters, alternatives
 
     return None, None, None
 
@@ -341,7 +329,7 @@ def is_one_euclidean(instance: OrdinalInstance):
             tmp = voters + [alternatives[i] for i in C_set_plus]
 
             # TODO: see previous comment, delta currently as value
-            delta = max([abs(x - y) for x, y in itertools.permutations(tmp, 2)])
+            delta = max([abs(x - y) for x, y in itertools.permutations(tmp, 2)], default=0)
 
             y = dict()
             # add mapping of voters

preflibtools/properties/subdomains/ordinal/singlepeaked/singlepeakedness.py

@@ -9,7 +9,6 @@
 from itertools import combinations
 
 import numpy as np
-from mip import Model, xsum, BINARY, MINIMIZE, INTEGER, OptimizationStatus
 
 from preflibtools.properties.subdomains.consecutive_ones import isC1P
 
@@ -567,6 +566,15 @@ def is_single_peaked_ILP(instance):
     :rtype: Tuple(bool, str, list)
     """
 
+    try:
+        from mip import Model, MINIMIZE, BINARY, INTEGER, OptimizationStatus
+    except ImportError:
+        raise ImportError(
+            "The Single-Peaked ILP functions needs the python-mip package. This is no longer listed as a requirement "
+            "as we are slowly moving to PuLP for Python 3.13 compatibility. If you are using Python < 3.13, install "
+            "manually the python-mip package. If you are using Python 3.13, please help us translate this file to PuLP."
+        )
+
     if instance.data_type not in ("toc", "soc"):
         raise TypeError(
             "You are trying to test for single-peakedness on an instance of type "
@@ -669,6 +677,15 @@ def approx_SP_voter_deletion_ILP(instance, weighted=False):
             + ", this is not possible. Only toc and soc are allowed here."
         )
 
+    try:
+        from mip import Model, MINIMIZE, BINARY, INTEGER, OptimizationStatus, xsum
+    except ImportError:
+        raise ImportError(
+            "The Single-Peaked ILP functions needs the python-mip package. This is no longer listed as a requirement "
+            "as we are slowly moving to PuLP for Python 3.13 compatibility. If you are using Python < 3.13, install "
+            "manually the python-mip package. If you are using Python 3.13, please help us translate this file to PuLP."
+        )
+
     model = Model(sense=MINIMIZE)
 
     init_time = time.time()
@@ -784,6 +801,15 @@ def approx_SP_alternative_deletion_ILP(instance):
             + ", this is not possible. Only toc and soc are allowed here."
         )
 
+    try:
+        from mip import Model, MINIMIZE, BINARY, INTEGER, OptimizationStatus, xsum
+    except ImportError:
+        raise ImportError(
+            "The Single-Peaked ILP functions needs the python-mip package. This is no longer listed as a requirement "
+            "as we are slowly moving to PuLP for Python 3.13 compatibility. If you are using Python < 3.13, install "
+            "manually the python-mip package. If you are using Python 3.13, please help us translate this file to PuLP."
+        )
+
     model = Model(sense=MINIMIZE)
 
     init_time = time.time()

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "preflibtools"
-version = "2.0.32"
+version = "2.0.33"
 description = "A set of tools to work with preference data from the PrefLib.org website."
 authors = [
   { name = "Simon Rey", email = "reysimon@orange.fr" },
@@ -21,11 +21,12 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 requires-python = ">=3.7"
 dependencies = [
     "numpy",
-    "mip",
+    "pulp",
     "prefsampling>=0.1.7"
 ]
 

tests/instance/io/test_io_cat.py

@@ -54,7 +54,7 @@ def test_read_from_str(self):
     def test_read_from_url(self):
         instance = CategoricalInstance()
         instance.parse_url(
-            "https://www.preflib.org/static/data/aamas/00037-00000001.cat"
+            "https://raw.githubusercontent.com/PrefLib/PrefLib-Data/main/datasets/00037%20-%20aamas/00037-00000001.cat"
         )
 
     def test_read_autocorrect(self):

tests/instance/io/test_io_soi.py

@@ -40,7 +40,7 @@ def test_read_from_str(self):
 
     def test_read_from_url(self):
         instance = OrdinalInstance()
-        instance.parse_url("https://www.preflib.org/static/data/apa/00028-00000007.soi")
+        instance.parse_url("https://raw.githubusercontent.com/PrefLib/PrefLib-Data/main/datasets/00028%20-%20apa/00028-00000007.soi")
 
     def test_autocorrect(self):
         instance = OrdinalInstance()

tests/properties/subdomains/ordinal/test_singlepeakedness.py

@@ -23,7 +23,10 @@ def test_single_peakedness(self):
         assert is_single_peaked_axis(instance, [0, 1, 2]) is False
         assert is_single_peaked_axis(instance, [1, 0, 2]) is True
         assert is_single_peaked(instance)[0] is True
-        assert is_single_peaked_ILP(instance)[0] is True
+        try:
+            assert is_single_peaked_ILP(instance)[0] is True
+        except ImportError:
+            pass
         assert is_single_peaked_pq_tree(instance) is True
 
         instance = OrdinalInstance()
@@ -38,18 +41,27 @@ def test_single_peakedness(self):
         assert is_single_peaked_axis(instance, [1, 0, 2]) is False
         assert is_single_peaked(instance)[0] is True
         assert is_single_peaked(instance)[1] in ([0, 1, 2], [2, 1, 0])
-        assert is_single_peaked_ILP(instance)[0] is True
-        assert is_single_peaked_ILP(instance)[2] in ([0, 1, 2], [2, 1, 0])
+
+        try:
+            assert is_single_peaked_ILP(instance)[0] is True
+            assert is_single_peaked_ILP(instance)[2] in ([0, 1, 2], [2, 1, 0])
+        except ImportError:
+            pass
         assert is_single_peaked_pq_tree(instance) is True
 
         instance = OrdinalInstance()
         orders = [((0,), (1,), (2,)), ((2,), (0,), (1,)), ((1,), (2,), (0,))]
         instance.append_order_list(orders)
         assert is_single_peaked(instance)[0] is False
-        assert is_single_peaked_ILP(instance)[0] is False
+        try:
+            assert is_single_peaked_ILP(instance)[0] is False
+            assert approx_SP_voter_deletion_ILP(instance)[0] == 1
+            assert approx_SP_alternative_deletion_ILP(instance)[0] == 1
+            assert approx_SP_voter_deletion_ILP(instance)[0] == 1
+            assert approx_SP_alternative_deletion_ILP(instance)[0] == 1
+        except ImportError:
+            pass
         assert is_single_peaked_pq_tree(instance) is False
-        assert approx_SP_voter_deletion_ILP(instance)[0] == 1
-        assert approx_SP_alternative_deletion_ILP(instance)[0] == 1
 
         instance = OrdinalInstance()
         orders = [
@@ -58,16 +70,22 @@ def test_single_peakedness(self):
             ((2, 3), (1,), (0,), (4,)),
         ]
         instance.append_order_list(orders)
-        assert is_single_peaked_ILP(instance)[0] is True
+        try:
+            assert is_single_peaked_ILP(instance)[0] is True
+            assert approx_SP_voter_deletion_ILP(instance)[0] == 0
+            assert approx_SP_alternative_deletion_ILP(instance)[0] == 0
+        except ImportError:
+            pass
         assert is_single_peaked_pq_tree(instance) is True
-        assert approx_SP_voter_deletion_ILP(instance)[0] == 0
-        assert approx_SP_alternative_deletion_ILP(instance)[0] == 0
 
         instance = OrdinalInstance()
         instance.populate_mallows_mix(30, 7, 5)
-        is_single_peaked_ILP(instance)
-        approx_SP_voter_deletion_ILP(instance)
-        approx_SP_alternative_deletion_ILP(instance)
+        try:
+            is_single_peaked_ILP(instance)
+            approx_SP_voter_deletion_ILP(instance)
+            approx_SP_alternative_deletion_ILP(instance)
+        except ImportError:
+            pass
 
     def test_single_peakedness_prefsampling(self):
         for seed in range(50):