Abstract
In many settings, a collective decision has to be made over a set of alternatives that has a combinatorial structure: important examples are multi-winner elections, participatory budgeting, collective scheduling, and collective network design. A further common point of these settings is that agents generally submit preferences over issues (e.g., projects to be funded), each having a cost, and the goal is to find a feasible solution maximising the agents’ satisfaction under problem-specific constraints. We propose the use of judgment aggregation as a unifying framework to model these situations, which we refer to as collective combinatorial optimisation problems. Despite their shared underlying structure, collective combinatorial optimisation problems have so far been studied independently. Our formulation into judgment aggregation connects them, and we identify their shared structure via five case studies of well-known collective combinatorial optimisation problems, proving how popular rules independently defined for each problem actually coincide. We also chart the computational complexity gap that may arise when using a general judgment aggregation framework instead of a specific problem-dependent model.
Article PDF
Similar content being viewed by others
Avoid common mistakes on your manuscript.
Data Availability
The datasets for the experiments in the appendix generated and analysed during the current study are available from the corresponding author on reasonable request.
Code Availability
The code for performing the experiments in the appendix is available from the corresponding author on reasonable request.
Notes
The experiments ran on an Intel i7 processor at 4.2 GHz with 4 physical and 8 logical cores and 32 GB of memory. At any time, six instances were computed in parallel.
References
Abdelmaguid, T.F.: An efficient mixed integer linear programming model for the minimum spanning tree problem. Mathematics 6(10), 183 (2018)
Aziz, H., Faliszewski, P., Grofman, B. et al.: Egalitarian committee scoring rules. In: Proceedings of the 27th International Joint Conference on Artificial Intelligence (IJCAI-2018) (2018)
Baumeister, D., Boes, L., Hillebrand, J.: Complexity of manipulative interference in participatory budgeting. In: Proceedings of the 7th international conference on algorithmic decision theory (ADT-2021) (2021)
Botan, S., de Haan, R., Slavkovik, M. et al.: Egalitarian judgment aggregation. In: Proceedings of the 20th international conference on autonomous agents and multiagent systems (AAMAS-2021) (2021)
Brams, S.J., Kilgour, D.M., Sanver, M.R.: A minimax procedure for electing committees. Public Choice 132(3–4), 401–420 (2007)
Bredereck, R., Faliszewski, P., Kaczmarczyk, A. et al.: An experimental view on committees providing justified representation. In: Proceedings of the 28th international joint conference on artificial intelligence (IJCAI-2019) (2019)
Chamberlin, J.R., Courant, P.N.: Representative deliberations and representative decisions: proportional representation and the Borda rule. The American Political Science Review, pp. 718–733 (1983)
Chingoma, J., Endriss, U., de Haan, R.: Simulating multiwinner voting rules in judgment aggregation. In: Proceedings of the 21st international conference on autonomous agents and multiagent systems (AAMAS-2022) (2022)
Conati, A., Niskanen, A., Järvisalo, M.: Sat-based judgment aggregation. In: Proceedings of the 2023 international conference on autonomous agents and multiagent systems (AAMAS-2023) (2023)
Darmann, A., Klamler, C., Pferschy, U.: Computing spanning trees in a social choice context. In: Proceedings of the 2nd international workshop on computational social choice (COMSOC-2008) (2008)
Darmann, A., Klamler, C., Pferschy, U.: Maximizing the minimum voter satisfaction on spanning trees. Math. Soc. Sci. 58(2), 238–250 (2009)
Eaton, J.W., Bateman, D., Hauberg, S. et al.: GNU Octave version 5.2.0 manual: A high-level interactive language for numerical computations (2020). https://www.gnu.org/software/octave/doc/v5.2.0/
Endriss, U.: Judgment aggregation. In: Brandt, F., Conitzer, V., Endriss, U., et al. (eds.) Handbook of Computational Social Choice. chap 17 (2016)
Endriss, U.: Judgment aggregation with rationality and feasibility constraints. In: Proceedings of the 17th international conference on autonomous agents and MultiAgent systems (AAMAS-2018) (2018)
Endriss, U., de Haan, R.: Complexity of the winner determination problem in judgment aggregation: Kemeny, Slater, Tideman, Young. In: Proceedings of 14th international conference on autonomous agents and multiagent systems (AAMAS-2015) (2015)
Endriss, U., de Haan, R., Lang, J., et al.: The complexity landscape of outcome determination in judgment aggregation. Journal of Artificial Intelligence Research 69, 687–731 (2020)
Escoffier, B., Gourvès, L., Monnot, J.: Fair solutions for some multiagent optimization problems. Auton. Agent. Multi-Agent Syst. 26(2), 184–201 (2013)
Everaere, P., Konieczny, S., Marquis, P.: On egalitarian belief merging. In: Proceedings of the 14th international conference on the principles of knowledge representation and reasoning (KR-2014) (2014)
Everaere, P., Konieczny, S., Marquis, P.: Belief merging versus judgment aggregation. In: Proceedings of the 14th international conference on autonomous agents and MultiAgent systems (AAMAS-2015) (2015)
Fluschnik, T., Skowron, P., Triphaus, M., et al.: Fair knapsack. In: Proceedings of the 33rd AAAI conference on artificial intelligence (AAAI-2019) (2019)
Garey, M.R., Johnson, D.S.: Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H, Freeman and Company (1979)
Goel, A., Krishnaswamy, A.K., Sakshuwong, S. et al.: Knapsack voting. Collective Intelligence 1 (2015)
Grandi, U., Endriss, U.: Lifting integrity constraints in binary aggregation. Artif. Intell. 199–200, 45–66 (2013)
Grossi, D., Pigozzi, G.: Judgment Aggregation: A Primer. Synthesis Lectures on Artificial Intelligence and Machine Learning (2014)
de Haan, R.: Hunting for tractable languages for judgment aggregation. In: Proceedings of the 16th international conference on principles of knowledge representation and reasoning (KR-2018) (2018)
de Haan, R., Slavkovik, M.: Answer set programming for judgment aggregation. In: Proceedings of the 28th international joint conference on artificial intelligence (IJCAI-2019) (2019)
Klamler, C., Pferschy, U., Ruzika, S.: Committee selection under weight constraints. Math. Soc. Sci. 64(1), 48–56 (2012)
Konieczny, S., Pino Pérez, R.: Logic based merging. J. Philos. Log. 40(2), 239–270 (2011)
Lackner, M., Skowron, P.: Multi-Winner Voting with Approval Preferences. Springer Briefs in Intelligent Systems, Springer (2023)
Lang, J., Slavkovik, M.: Judgment aggregation rules and voting rules. In: Proceedings of the 3rd International Conference on Algorithmic Decision Theory (ADT-2013) (2013)
Lang, L., Pigozzi, P., Slavkovik, M., et al.: A partial taxonomy of judgment aggregation rules and their properties. Soc. Choice Welfare 48(2), 327–356 (2017)
Nehring, K., Pivato, M.: The median rule in judgement aggregation. Econ. Theor. 73(4), 1051–1100 (2022)
Nehring, K., Pivato, M., Puppe, C.: The Condorcet set: Majority voting over interconnected propositions. Journal of Economic Theory 151, 268–303 (2014)
Papadimitriou, C.H., Yannakakis, M.: The complexity of facets (and some facets of complexity). In: Proceedings of the 14th annual ACM symposium on theory of computing (1982)
Pascual, F., Rzadca, K., Skowron, P.: Collective schedules: Scheduling meets computational social choice. In: Proceedings of the 17th international conference on autonomous agents and MultiAgent systems (AAMAS-2018) (2018)
Rey, S., Endriss, U., de Haan, R.: Designing participatory budgeting mechanisms grounded in judgment aggregation. In: Proceedings of the 17th international conference on principles of knowledge representation and reasoning (KR-2020) (2020)
Skowron, P., Faliszewski, P.: Chamberlin-Courant rule with approval ballots: Approximating the MaxCover problem with bounded frequencies in FPT time. Journal of Artificial Intelligence Research 60, 687–716 (2017)
Skowron, P., Faliszewski, P., Slinko, A.M.: Achieving fully proportional representation: Approximability results. Artif. Intell. 222, 67–103 (2015)
Sonar, C., Dey, P., Misra, N.: On the complexity of winner verification and candidate winner for multiwinner voting rules. In: Proceedings of the 29th international joint conference on artificial intelligence (IJCAI-2020) (2020)
Sreedurga, G., Ratan Bhardwaj, M., Narahari, Y.: Maxmin participatory budgeting. In: Proceedings of the 31st international joint conference on artificial intelligence (IJCAI-22) (2022)
Talmon, N., Faliszewski, P.: A framework for approval-based budgeting methods. In: Proceedings of the 33th AAAI conference on artificial intelligence (2019)
Acknowledgements
We thank the AMAI reviewers, as well as the reviewers of M-PREF 2022, for their valuable feedback. This work was supported by the French “Agence Nationale de la Recherche”, both as part of the ‘Investissements d’avenir’ programme, reference ANR-19-P3IA-0001 (PRAIRIE 3IA Institute), and by the ANR JCJC project SCONE (ANR 18-CE23-0009-01). It was also supported by the NRW project "Online Participation”.
Author information
Authors and Affiliations
Corresponding author
Additional information
Publisher's Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Appendix: General solvers
Appendix: General solvers
Our general framework of weighted asymmetric judgment aggregation can not only be used for theoretical comparisons of rules for specific CCO settings but also to obtain a modular implementation of the rules: by simply plugging in the constraints, one can focus on a particular application. Although there is no specific solver for weighted asymmetric judgment aggregation, integer linear programming (ILP) is an ideal choice for such a solver. Each rule given in this paper (see Section 2.2) can be translated into an ILP formulation, as shown in the following subsection.
To the best of our knowledge, this is the first ILP formulation for judgment aggregation rules—prior to this, the only other implementations have used answer set programming [26] and SAT solvers [9]. One of the benefits of using the ILP formalism is the ability to rely on its vast literature and efficient solvers. Furthermore, we conjecture that many more judgment aggregation rules (and their weighted extensions) can be expressed as an ILP, which may not be straightforward when using other solvers that do not use cardinal weights (such as SAT solvers, where weights might have to be simulated). A benefit of ILP solvers is that many are efficient, and constraints are expressed compactly as sets of inequalities. Moreover, the use of JA as a general model for CCO problems can be motivated by the natural translation of the rules into ILP. This is unlike some of the other general solvers where the translations of the rules are far more involved.
Note that the constraints for the CCO problems described in Section 3 are already presented as sets of linear inequations, allowing us to study those in ILP directly.
1.1 Integer Linear Program Formulations for Weighted Asymmetric Judgment Aggregation Rules
We give an ILP formulation for each of our studied rules. In the following, each agenda item \(a_j \in A\) is given as binary variable \(a_j \in \{0,1\}\) and we assume that we are given a (possibly empty) feasibility constraint \(\Gamma _F\) as a set of linear inequalities.
1.1.1 The (weighted) median rule
Following Definition 1, we can formulate \( WMed \) as the following ILP.
1.1.2 The (weighted) egalitarian rule
To express the egalitarian rule in ILP we use an additional variable Z, which represents the lowest score of any agent (and thus should be maximised). This maximisation is done subject to the feasibility constraints (\(\Gamma _F\)) and the intersection of the outcome assignment over the agenda A with respect to each agent’s ballot, which must be greater than or equal to Z. A similar ILP formulation in the context of participatory budgeting was given by Sreedurga et al. [40].
1.1.3 The (weighted) ranked agenda rule
Note that \( Rank \) and \( WRank \) can be computed efficiently for easy-to-solve constraints (e.g., a participatory budgeting constraint). Nevertheless, we provide an ILP formulation to compute the outcome in general. In a pre-processing step, we compute the order in which decisions over the agenda are made, i.e., descending by the agents (weighted) support, where ties are broken alphabetically. For \(a \in A\), let \(\pi _a\) be the number of items that are ranked after a in that order. Then, for the ILP formulation of \( WRank \) it is sufficient to ensure that it is always preferred to include issues that are processed earlier over all issues that are processed later.
1.1.4 The Chamberlin-Courant rule
For an ILP formulation of the Chamberlin-Courant rule, we take inspiration from Talmon and Faliszewski [41]—see also [38] for a translation of the multi-winner election variant into ILP. We need an extra variable \(c_i\) for each agent \(i\in \mathcal {N}\) that will model their satisfaction. In particular, \(c_i\) will be set to 1 if there is a project in the outcome which the agent approves.
1.2 A Case Study for General Solvers: Collective Networking
In this section, we provide a case study for the implementation of the collective networking problem (described in Section 3.3) without a budget constraint, comparing the processing time of three (binary) rules: the median rule (\( Med \)), the egalitarian rule (\( Egal \)), and the Chamberlin-Courant rule (\( CC \)). We do not study the (weighted) ranked agenda rules, as they are solvable in polynomial time (if it can be checked in polynomial time whether a partial assignment can be extended to a full assignment satisfying the given constraint). The implementation used the open-source GNU Octave software [12], and its standard ILP solver glpk, using two-phase primal simplex method. Our implementation is modular: i.e., the same set-up can be altered to account for any CCO problem by changing the problem-specific components (the agenda, the constraints, and the CCO rule).
Recall that in the collective networking problem, we have a graph \(G=(V,E)\) and the agents vote on the edges E in the corresponding agenda, while the rule has to find a collective spanning tree. Regarding the constraints, we allow for any possible ballot and we only impose that the outcome must be a spanning tree, thus \(\Gamma _F\) is composed of the ILP constraints expressed in (1), (2) and (3).
We generate the underlying network in the form of 49 connected graphs \(G=(V,E)\) with number of nodes varying between 6 and 8, i.e., \(V\in [6,8]\). For each value of V we generate connected graphs with \(E\in \left[ \vert V\vert -1, \frac{\vert V\vert (\vert V\vert -1)}{2}\right] \): i.e., the graphs vary from being trees (for \(\vert E\vert =\vert V\vert -1\)) to being complete (for \(\vert E\vert = \frac{\vert V\vert (\vert V\vert -1)}{2}\)). Each graph is randomly generated as follows, for a given \(\vert V\vert \) and \(\vert E\vert =e\).
We initially let S and \(S'\) be two sets such that one element \(v_0\) of V is in S (i.e., \(v_0\in S\)) and \(S'=V\backslash \{v_0\}\). The set S and \(S'\) can be seen as the set of connected and unconnected nodes, respectively. The algorithm iteratively chooses, at random, an item \((v_i,v_j)\in S\times S'\), moves \(v_j\) from \(S'\) to S, and adds \((v_i,v_j)\) to the set of edges E. When \(S'\) is empty, we randomly add \(e-(\vert V\vert -1)\) extra edges from \((V\times V)\setminus E\).
We let \(\vert \mathcal {N}\vert = 100\). On each generated graph G we create 10 base profiles. Each base profile (bp), is an \(n\times E\) matrix, where for each \(i\in \mathcal {N}\) we have that \(bp_i\in (0,1]^E\): that is, for each item of the agenda a real number between 0 and 1 is assigned to represent the acceptance rate of an issue by an agent. Each base profile is then transformed into 9 new profiles as follows, under the variant of the p-impartial culture model presented by [6]. According to this model, when generating approval voting ballots, one can assume that every agent independently approves each item of the agenda with probability p. Therefore, for each base profile (generated for each graph) we create 9 profiles, one for every \(p\in \{0.1,\ldots ,0.9\}\). If the value of an entry b in the base profile is such that \(b\le p\), then in the created profile the agent’s preference on this issue will be an approval, and an abstention otherwise.
Therefore, for each of our generated graphs (a total of 49 graphs), we created a total of 90 profiles originating from 10 base profiles and the 9 probabilities from our p-impartial culture assumption. Thus, we ran the three CCO rules on 4410 instances. We then run the ILP solver on each profile and its related graph to find an outcome for the three rules: \( Med , Egal \) and \( CC \).
For each generated problem instance we measured the processing times of computing the outcome of three rules, given varying levels of the p-impartial culture and number of nodes in the underlying initial network.Footnote 1
We begin by comparing the run-times of the three CCO rules with respect to four levels of acceptance, \(p\in \{0.2, 0.4, 0.6, 0.8\}\) and varying the number of nodes in the graph (we only highlight four of our nine values of p). Figure 2 shows, for each value of p, the mean processing times over all profiles and all generated networks varying the number of nodes of the network \(V\in \{6,7,8\}\). In Fig. 2 we use a log\(_2\)-scale on the y-axis due to the exponential increase in processing times.
If we focus on \( CC \), we observe that the run-time is inversely proportional to the acceptance level p, confirming the intuition that finding a collective spanning tree with \( CC \) is more difficult with sparse ballots.
The \( Med \) rule is slower to compute than the other rules for almost all p values (with some exceptions for small values of p against \( CC \)). Observe that without additional constraints on the budget, the \( Med \) rule is equivalent to finding the maximum spanning tree where the weights of the edges are determined by how many voters approved them. Therefore, the complexity of computing the outcome of \( Med \) is proportional to \(N \cdot p\), i.e., the weights of the edges. A future step would be to check if the same increase in run-time can be observed for the related rule \( WMed \).
Finally, the run-time of \( Egal \) increases steadily with the number of nodes when \(p= 0.2, 0.4\), while for \(p=0.6, 0.8\) it increases at a much quicker rate. This can be explained by referring back to (A2), where we see that \( Egal \) maximises the value of variable Z, whose upper bound is the minimum number of items that any agents has approved. Therefore, when p is low, so is the upper bound on Z, reducing the search space; while when p is high there are more values which Z can take.
The same experiments for networks with 9 or more nodes resulted in some of the instances not completing before the chosen time-out of 1200 seconds. The observed behaviour varied with each rule: for \( Med \) the non-completing instances corresponded to the graphs that were close to being complete, whereas for \( Med \) and \( Egal \) the pattern was more complex, and it seemed to depend on both the structure of the graph as well as the profile of individual ballots.
Figure 3 presents the mean run-times of the three chosen rules for varying levels of acceptance p, starting from a fixed complete network with \(\vert V\vert =8\) and \(\vert E\vert =28\). Each bar represents the mean run-time for 10 different profiles, for a total of 90 instances. The figure highlights the exponential increase in running time of \( Egal \), and confirms the observation that \( CC \) is easy on complete graphs.
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
Boes, L., Colley, R., Grandi, U. et al. Collective combinatorial optimisation as judgment aggregation. Ann Math Artif Intell (2023). https://doi.org/10.1007/s10472-023-09910-w
Accepted:
Published:
DOI: https://doi.org/10.1007/s10472-023-09910-w