Generalising ILP schemes

Author: Simon-Rey

tests/test_rules/test_chamberlin_courant.py

@@ -30,24 +30,25 @@ def test_cc_on_trivial_instances(self):
         self.assertEqual(len(res), 0)
 
     def test_cc_on_specific_instances(self):
-        a = Alternative("a")
-        b = Alternative("b")
-        c = Alternative("c")
-        d = Alternative("d")
-        e = Alternative("e")
-        alternatives = [a, b, c, d, e]
-        ballots = [
-            TrichotomousBallot(approved=[a, b], disapproved=[c]),
-            TrichotomousBallot(approved=[c]),
-        ]
-        profile = TrichotomousProfile(ballots, alternatives=alternatives)
-        res = chamberlin_courant(profile, 3)
-        self.assertEqual(len(res), 3)
-
-        profile.add_ballot(TrichotomousBallot(approved=[a], disapproved=[c]))
-        res = chamberlin_courant(profile, 2)
-        self.assertIn(a, res)
-        self.assertNotIn(c, res)
+        for cc_func in [chamberlin_courant, chamberlin_courant_brute_force]:
+            a = Alternative("a")
+            b = Alternative("b")
+            c = Alternative("c")
+            d = Alternative("d")
+            e = Alternative("e")
+            alternatives = [a, b, c, d, e]
+            ballots = [
+                TrichotomousBallot(approved=[a, b], disapproved=[c]),
+                TrichotomousBallot(approved=[c]),
+            ]
+            profile = TrichotomousProfile(ballots, alternatives=alternatives)
+            res = cc_func(profile, 3)
+            self.assertEqual(len(res), 3)
+
+            profile.add_ballot(TrichotomousBallot(approved=[a], disapproved=[c]))
+            res = cc_func(profile, 2)
+            self.assertIn(a, res)
+            self.assertNotIn(c, res)
 
     def test_with_brute_force(self):
         for _ in range(50):

tests/test_rules/test_max_net_support.py

@@ -0,0 +1,43 @@
+import random
+from unittest import TestCase
+
+from tests.random_instances import get_random_profile
+from trivoting.election import TrichotomousProfile, Selection, Alternative, TrichotomousBallot
+from trivoting.rules import max_net_support
+from trivoting.rules.chamberlin_courant import chamberlin_courant, chamberlin_courant_brute_force
+from trivoting.rules.max_net_support import max_net_support_ilp
+
+
+class TestMaxNetSupport(TestCase):
+
+    def test_max_net_support_on_random_instance(self):
+        for _ in range(50):
+            profile = get_random_profile(20, 50)
+            max_size = random.randint(1, len(profile.alternatives))
+            res = max_net_support(profile, max_size, resoluteness=True)
+            self.assertLessEqual(len(res), max_size, f"Failure with max_net_support on: {profile}, k={max_size}")
+
+    def test_max_net_support_on_trivial_instances(self):
+        # Empty profile
+        profile = TrichotomousProfile()
+        self.assertEqual(max_net_support(profile, 0), Selection())
+
+        # Only disapproved
+        alternatives = [Alternative(str(i)) for i in range(10)]
+        negative_ballots = [
+            TrichotomousBallot(disapproved=alternatives[:6]) for _ in range(10)
+        ]
+        profile = TrichotomousProfile(negative_ballots, alternatives=alternatives)
+        res = max_net_support(profile, len(alternatives))
+        self.assertEqual(len(res), 0)
+
+    def test_max_net_support_with_ilp(self):
+        for _ in range(50):
+            for m in range(2, 7):
+                profile = get_random_profile(m, 50)
+                max_size = random.randint(1, len(profile.alternatives))
+                res1 = max_net_support(profile, max_size, resoluteness=True)
+                support1 = profile.num_covered_ballots(res1)
+                res2 = max_net_support_ilp(profile, max_size, resoluteness=True)
+                support2 = profile.num_covered_ballots(res1)
+                self.assertEqual(support1, support2, f"Failure max_net_support comparing to brute-force: {profile}, k={max_size}, ilp={res1} (s={support1}), ordering={res2} (s={support2})")

tests/test_rules/test_on_abcvoting_instances.py

@@ -16,7 +16,7 @@
     MaxSatisfactionILPBuilder,
 )
 from trivoting.rules.chamberlin_courant import chamberlin_courant
-from trivoting.rules.max_satisfaction import max_satisfaction_ilp, max_satisfaction
+from trivoting.rules.max_net_support import max_net_support, max_net_support_ilp
 from trivoting.rules.thiele import (
     thiele_method,
     PAVILPKraiczy2025,
@@ -115,8 +115,8 @@ def exhaustivee_cc(
         partial(sequential_thiele, thiele_score_class=ApprovalOnlyScore),
         partial(sequential_thiele, thiele_score_class=SatisfactionScore),
         partial(thiele_method, ilp_builder_class=MaxSatisfactionILPBuilder),
-        max_satisfaction_ilp,
-        max_satisfaction,
+        max_net_support_ilp,
+        max_net_support,
     ],
     "cc": exhaustivee_cc,
     # ABCvoting only has MES with completion...

trivoting/rules/__init__.py

@@ -17,6 +17,8 @@
     DisapprovalLinearTax,
 )
 from trivoting.rules.phragmen import sequential_phragmen
+from trivoting.rules.chamberlin_courant import chamberlin_courant
+from trivoting.rules.max_net_support import max_net_support
 
 __all__ = [
     "thiele_method",
@@ -34,4 +36,6 @@
     "TaxKraiczy2025",
     "DisapprovalLinearTax",
     "sequential_phragmen",
+    "chamberlin_courant",
+    "max_net_support",
 ]

trivoting/rules/chamberlin_courant.py

@@ -9,10 +9,11 @@
     LpBinary,
     LpVariable,
     LpInteger,
-    HiGHS,
+    HiGHS, LpAffineExpression,
 )
 
 from trivoting.election import AbstractTrichotomousProfile, Selection
+from trivoting.rules.ilp_schemes import ILPBUilder, ilp_optimiser_rule
 from trivoting.utils import generate_subsets
 
 
@@ -38,6 +39,35 @@ def chamberlin_courant_brute_force(
         return arg_max_coverage[0]
     return arg_max_coverage
 
+class ChamberlinCourantILPBuilder(ILPBUilder):
+    model_name = "ChamberlinCourant"
+
+    def init_vars(self) -> None:
+        super(ChamberlinCourantILPBuilder, self).init_vars()
+
+        self.vars["sat_var"] = dict()
+        self.vars["dissat_var"] = dict()
+        self.vars["cc_var"] = dict()
+
+        for i, ballot in enumerate(self.profile):
+            sat_var = LpVariable(f"sat_{i}", lowBound=-self.max_size_selection, upBound=self.max_size_selection, cat=LpInteger)
+            dissat_var = LpVariable(f"dissat_{i}", lowBound=-self.max_size_selection, upBound=self.max_size_selection, cat=LpInteger)
+            cc_var = LpVariable(f"cc_{i}", cat=LpBinary)
+
+            self.model += sat_var == lpSum(self.vars["selection"][alt] for alt in ballot.approved)
+            self.model += dissat_var == lpSum(self.vars["selection"][alt] for alt in ballot.disapproved)
+
+            # Linearisation of z = 1 if x > y and z = 0 otherwise
+            self.model += (sat_var - dissat_var >= 1 - (1 - cc_var) * self.max_size_selection)
+            self.model += (sat_var - dissat_var <= cc_var * self.max_size_selection)
+
+            self.vars["sat_var"][i] = sat_var
+            self.vars["dissat_var"][i] = dissat_var
+            self.vars["cc_var"][i] = cc_var
+
+    def objective(self) -> LpAffineExpression:
+        return lpSum(self.vars["cc_var"].values())
+
 
 def chamberlin_courant(
     profile: AbstractTrichotomousProfile,
@@ -75,114 +105,5 @@ def chamberlin_courant(
         The selection if resolute (:code:`resoluteness == True`), or a list of selections
         if irresolute (:code:`resoluteness == False`).
     """
-    model = LpProblem("ChamberlinCourant", LpMaximize)
-
-    selection_vars = {
-        alt: LpVariable(f"y_{alt.name}", cat=LpBinary) for alt in profile.alternatives
-    }
-
-    # Select no more than allowed
-    model += lpSum(selection_vars.values()) <= max_size_selection
-
-    # Handle initial selection
-    if initial_selection is not None:
-        for alt in initial_selection.selected:
-            model += selection_vars[alt] == 1
-        if not initial_selection.implicit_reject:
-            for alt in initial_selection.rejected:
-                model += selection_vars[alt] == 0
-
-    # Voters satisfaction variables
-    voter_details = []
-    for i, ballot in enumerate(profile):
-        voter = {
-            "ballot": ballot,
-            "multiplicity": profile.multiplicity(ballot),
-            "sat_var": LpVariable(
-                f"sat_{i}", lowBound=-max_size_selection, upBound=max_size_selection, cat=LpInteger
-            ),
-            "dissat_var": LpVariable(
-                f"disat_{i}", lowBound=-max_size_selection, upBound=max_size_selection, cat=LpInteger
-            ),
-            "cc_var": LpVariable(f"cc_{i}", cat=LpBinary),
-        }
-        voter_details.append(voter)
-
-    # Constraint voter_details to ensure proper counting
-    for voter in voter_details:
-        model += voter["sat_var"] == lpSum(
-            selection_vars[alt] for alt in voter["ballot"].approved
-        )
-        model += voter["dissat_var"] == lpSum(
-            selection_vars[alt] for alt in voter["ballot"].disapproved
-        )
-
-        # Linearisation of z = 1 if x > y and z = 0 otherwise
-        model += (
-            voter["sat_var"] - voter["dissat_var"]
-            >= 1 - (1 - voter["cc_var"]) * max_size_selection
-        )
-        model += (
-            voter["sat_var"] - voter["dissat_var"]
-            <= voter["cc_var"] * max_size_selection
-        )
-
-    # Objective: max PAV score
-    model += lpSum(voter["cc_var"] for voter in voter_details)
-
-    status = model.solve(HiGHS(msg=verbose, timeLimit=max_seconds))
-
-    all_selections = []
-
-    if status == LpStatusOptimal:
-        selection = Selection(implicit_reject=True)
-        for alt, v in selection_vars.items():
-            if value(v) >= 0.9:
-                selection.add_selected(alt)
-        all_selections.append(selection)
-    else:
-        raise ValueError(
-            f"Solver did not find an optimal solution, status is {status}."
-        )
-
-    if resoluteness:
-        return all_selections[0]
-
-    # If irresolute, we solve again, banning the previous selections
-    model += lpSum(voter["cc_var"] for voter in voter_details) == value(model.objective)
-
-    previous_selection = selection
-    while True:
-        # See http://yetanothermathprogrammingconsultant.blogspot.com/2011/10/integer-cuts.html
-        model += (
-            lpSum((1 - selection_vars[a]) for a in previous_selection.selected)
-            + lpSum(
-                selection_vars[a] for a in selection_vars if a not in previous_selection
-            )
-        ) >= 1
-
-        model += (
-            lpSum(selection_vars[a] for a in previous_selection.selected)
-            - lpSum(
-                selection_vars[a] for a in selection_vars if a not in previous_selection
-            )
-        ) <= len(previous_selection) - 1
-
-        status = model.solve(HiGHS(msg=verbose, timeLimit=max_seconds))
-
-        if status != LpStatusOptimal:
-            break
-
-        previous_selection = Selection(
-            [
-                a
-                for a in selection_vars
-                if value(selection_vars[a]) is not None
-                and value(selection_vars[a]) >= 0.9
-            ],
-            implicit_reject=True,
-        )
-        if previous_selection not in all_selections:
-            all_selections.append(previous_selection)
-
-    return all_selections
+    ilp_builder = ChamberlinCourantILPBuilder(profile, max_size_selection, initial_selection, max_seconds=max_seconds, verbose=verbose)
+    return ilp_optimiser_rule(ilp_builder, resoluteness=resoluteness)