A General Framework for Participatory Budgeting with Additional Constraints ∗

We introduce a new approach for designing rules for participatory budgeting, the problem of deciding on the use of public funds based directly on the views expressed by the citizens concerned. The core idea is to embed instances of the participatory budgeting problem into judgment aggregation, a powerful general-purpose framework for modelling collective decision making. Taking advantage of the possibilities oﬀered by judgment aggregation, we enrich the familiar setting of participatory budgeting with additional constraints, namely dependencies between projects and quotas regarding diﬀerent types of projects. We analyse the rules obtained in both algorithmic and axiomatic terms.


Introduction
Participatory budgeting (PB) is an instrument intended to improve the democratic process by allowing citizen to directly express their views regarding the use of public funds (Cabannes, 2004). Since its first use for municipal budget allocation in Brazil over three decades ago, PB has been adopted across the world (Dias, 2018;Wampler et al., 2021). The typical PB process is divided into two stages (Shah, 2007;Wampler, 2012). In the first stage, citizens can submit project proposals they have for the city. Some of these proposals are then shortlisted and the citizens are asked to vote on which of the shortlisted projects they want to be implemented, given a budget constraint. While this describes the typical scenario of a PB process, each local implementation comes with its own specificities. In particular, it is quite common to encounter additional constraints on the range of projects that can be funded. In this paper, we develop a general framework that allows us to easily incorporate such additional constraints within the standard model for PB.
What types of additional constraints are used in real-life PB processes? By focusing on the case of the city of Paris (City of Paris, 2022) we can for instance learn that projects are sometimes grouped into categories and that special constraints apply to these categories. For instance, some projects are labelled "low income neighbuorhood" and a specific number of them has to be selected in the final bundle to be funded. Another category of projects are those designated for the whole city (and not a specific neighbourhood), and this category may also have a lower quota attached to it. Similar constraints can also be found in PB processes in Lisbon (Allegretti and Antunes, 2014) or in Amsterdam (City of Amsterdam, 2022). Other natural constraints that we can imagine include the existence of dependencies between projects, such as when some projects can only be realised if others are as well.
The challenge is then to incorporate such constraints into the formal study of PB. This is not a straightforward task. Indeed, most of the existing formal work in (computational) social choice regarding PB views voting on projects as a generalisation of multiwinner voting (see, e.g., Aziz et al., 2018;Talmon and Faliszewski, 2019;Peters et al., 2021). PB mechanisms that have been introduced in the literature are thus grounded in multiwinner voting, with an additional budget constraint. While this can provide useful intuitions regarding, for instance, the type of normative desiderata we may wish to postulate for PB, it does not allow for great flexibility. In particular, it does not permit us to model the more expressive forms of PB we discussed earlier. Instead, by following this approach, one would need to redefine and and analyse from scratch everything for every specific variation of the base model motivated by real-life instances of PB. To address this problem, we develop in this paper a complementary approach, and study PB as a special case of judgment aggregation (JA), a highly expressive general-purpose aggregation framework (List and Puppe, 2009;Grossi and Pigozzi, 2014;. JA is a framework in which opinions over binary issues are aggregated in a manner that ensures conformance to some feasibility constraint expressed in propositional logic. It is known to generalise many forms of preference aggregation and voting scenarios (Dietrich and List, 2007;Lang and Slavkovik, 2013;Endriss, 2018;Chingoma et al., 2022), including PB (De Haan, 2018). This high expressivity is particularly appealing for us as it allows us to easily encode additional constraints for PB. However, this comes at a computational cost that could be prohibitive if left unchecked. Indeed, the computational complexity of computing outcomes of common JA rules is typically very high , and hard even relative to complexity classes beyond NP. One of the main challenges we face in our endeavour thus is to find ways of implementing PB via JA in an efficient manner.
To cope with this algorithmic challenge, we explore the idea of looking for tractable fragments of JA. Of particular interest in this context is the prior work of De Haan (2018), who developed the idea of modelling JA problems using Boolean circuits in decomposable negation normal form (DNNF circuits) to save on the computational cost. We further develop this approach to express PB problems with additional constraints as DNNF circuits for JA, which can then be used in an efficient manner (from a computational perspective). More specifically, our contribution regarding the algorithmic part of this research agenda consists in two efficient embeddings of PB into JA for two kinds of additional constraints, namely dependencies between projects and quotas over categories of projects.
Of course, an expressive framework for modelling PB scenarios and a set of algorithmically efficient PB rules alone are not sufficient. We also require a good understanding of whether the rules we design are normatively adequate to be used in the context of PB. In the second part of the paper we therefore focus on this aspect and provide an axiomatic analysis of the rules we propose.
Among the requirements that have been introduced to study PB rules, the most fundamental one is probably exhaustiveness. It rules out any under-use of the budget by stating that it should not be possible for the leftover budget to be so large as to still allowing us to fund a further project. Interestingly, this requirement is incompatible with the usual view that JA rules take on logical negation. In JA, it is indeed standard to consider that when an agent says no to a given issue, selecting that issue would yield some dissatisfaction for the agent. When it comes to PB, the semantics of negation is usually 'weaker' in the following sense: An agent not approving of a given project would be neutral about whether the project will be selected. This motivates the introduction of asymmetrical counterparts of typical JA rules with this weaker take on negation. This approach allows us to define exhaustive rules within JA. We also provide an algorithmic solution to enforce exhaustiveness, but one that only works in limited cases (when the budget limit is uni-dimensional).
Incorporating exhaustiveness in JA is a mandatory step to make sure that the JA rules are potential candidates for PB rules, but it is not enough. To provide additional insight, we deepen our axiomatic analysis by studying how JA rules behave with respect to the monotonicity axioms for PB introduced by Talmon and Faliszewski (2019).
Thus, our contribution in this paper may be summarised as follows: • We introduce a general framework for PB that makes it possible to easily incorporate additional constraints, and we exemplify this approach with two natural constraints on projects, namely dependencies and quotas.
• We demonstrate that, even though this more general framework is expressive enough to cover cases that require some extra computational cost, in many natural settings the overhead is manageable. • We show that some of the typical JA rules are good candidates to be used in the context of PB, at least in view of monotonicity requirements.
Overall, our analysis demonstrates that this framework is suitable for the theoretical analysis of PB rules. Its main added value is the flexibility it offers to study of PB rules across different variants of the standard PB setting. Thanks to this framework, one can incorporate extra constraints for PB by "only" investigating the specific encoding of the constraint on the JA side, thereby immediately making available all other results previously established for the basic framework without those constraints. In particular, once a rule has been proven to satisfy a certain axiom, it will continue to do so, regardless of the extra constraints. 1 In this sense, this framework allows for an efficient study of a myriad of variations around the standard PB setting.

Related Work
According to the terminology of Aziz and Shah (2020), the basic model of PB we focus on in this paper is called combinatorial PB with binary projects and approval ballots. Several types of normative requirements have been studied for this framework. An important emphasis has been put on fairness and proportionality requirements (Fain et al., 2016;Aziz et al., 2018;Peters et al., 2021;Lackner et al., 2021;Los et al., 2022;Fairstein et al., 2022). Incentive compatibility is another important topic in the context of PB (Goel et al., 2019;Freeman et al., 2019;Rey et al., 2021). Other properties such as monotonicity requirements have also been studied (Talmon and Faliszewski, 2019). Much attention has been devoted to the algorithmic side of PB, too. Greedy and optimal welfare/fairness-maximising rules have been studied by Talmon and Faliszewski (2019), Fluschnik et al. (2019), Patel et al. (2021), andSreedurga et al. (2022). Using a different approach, Fain et al. (2016) and Freeman et al. (2019) instead studied PB solutions as market equilibria, in the spirit of the public decision making setting of Conitzer et al. (2017). While the review in the previous paragraph has focused on the standard model for PB, several extensions have also been explored. For instance, Lu and Boutilier (2011) considered an extension of PB where the cost of a project might depend on the number of agents choosing it; Benade et al. (2018) proposed different ballot formats for PB; Baumeister et al. (2020) focused on irresolute PB rules; Rey et al. (2021) investigated the interplay between the two stages we discussed in the introduction; Lackner et al. (2021) approached PB from a long-term perspective where several PB elections are held in sequence; Hershkowitz et al. (2021) looked into local versus global PB processes; Baumeister et al. (2022) studied PB settings with uncertainty on the cost and completion time of the projects. Particularly interesting for our concerns are the works of Jain et al. (2020) and Jain et al. (2021), who have investigated extensions of PB in which projects are grouped into categories, and where either the utility of each agent is a function of the number of selected projects from each category, or where there are specific budget limits for each category. Another exciting contribution is that of Fain et al. (2018) who followed a similar approach to ours. These authors considered a general setting of public decision making (introduced by Conitzer et al., 2017) and added different types of constraints to it (matroid, matching, and packing constraints), allowing for great flexibility on what can be modelled. Finally, Motamed et al. (2022) studied in more depth PB settings with multiple resources, an extension we also consider in this paper.
The study of how to embed preference aggregation problems into JA dates back to at least Dietrich and List (2007). The systematic study of how to embed voting rules into JA was then initiated by Lang and Slavkovik (2013) and later refined by Endriss (2018). Our work on the algorithmic aspects of such embeddings is based on the results of De Haan (2018), whose paper is also the first example for work investigating the embedding of PB into JA. Lately, a similar approach has been followed by Chingoma et al. (2022) to embed multiwinner voting into JA.

Paper Outline
We recall relevant definitions from PB and JA in Section 2 and then introduce our central definition of an embedding of PB into JA. Section 3 is devoted to the study of efficient embeddings for basic PB and the extensions we propose. Section 4 discusses exhaustiveness, and Section 5 contains the remainder of our axiomatic analysis. We draw our conclusions in Section 6.

Frameworks
In this section we recall basic definitions regarding the frameworks of participatory budgeting (PB) and judgment aggregation (JA). We also define the main concept of this paper, namely embeddings of PB instances into JA.

Participatory Budgeting
We mainly adopt the notation of Aziz and Shah (2020). PB is about selecting a set of projects to be funded, given a (possibly multi-dimensional) budget limit. The set of (binary) projects is denoted by P = {p 1 , . . . , p m }. Let R = {r 1 , . . . , r d } be a set of resources and b = (b 1 , . . . , b d ) a budget limit vector, with b i ∈ R ≥0 indicating the limit in terms of resource r i . The costs of the projects are defined by a cost function c : P × R → R ≥0 , indicating for a given project the cost in terms of the given resource. Slightly overloading notation, we use c(p) = (c(p, r 1 ), . . . , c(p, r d )) to denote the cost vector of project p. Moreover, for any subset P ⊆ P, let c(P, r) = p∈P c(p, r) and c(P ) = p∈P c(p). A problem instance I = R, b, P, c for PB consists of a set of resources R, a budget limit vector b, a set of projects P, and a cost function c. We denote by I the set of all such instances.
A solution of a PB problem instance, called a budget allocation, is a subset of projects π ⊆ P. A budget allocation π is said to be feasible if c(π) ≤ b. For a given I ∈ I, the set of all feasible budget allocations is denoted by A(I). A budget allocation π is said to be exhaustive if there is no project p ∈ P \ π such that c(π ∪ {p}) ≤ b. A EX (I) is the set of all feasible and exhaustive budget allocation for an instance I.
Before deciding which budget allocation to recommend, we consult the agents belonging to a set N = {1, . . . , n}. Each agent i ∈ N submits an approval ballot A i ⊆ P, giving rise to a profile A = (A 1 , . . . , A n ). For any given project p ∈ P, its approval score under profile A is defined as i∈N 1 p∈Ai , the number of agents approving of p. Without loss of generality, we assume that every project has an approval score of at least 1, as projects with approval score 0 can be removed in a pre-processing step. Finally, a PB rule is a function F : I × (2 P ) n → 2 2 P \ {∅} mapping any given instance I and profile A to a nonempty set F (I, A) ⊆ A(I) of feasible budget allocations. 2 Returning a set allows us to model possible ties in the outcome.

Judgment Aggregation
The specific JA framework we use is known as binary aggregation with integrity constraints (Grandi and Endriss, 2011). 3 Let L X be the set of propositional formulas over a given set X of propositional atoms, using the usual connectives ¬, ∨, ∧, →, and logical constants ⊥ and . Propositional atoms and their negations are called literals. For any subset of atoms X ⊆ X, we write Lit(X) = X ∪ {¬x | x ∈ X} for the set of literals corresponding to P . We often use x i to denote atoms and xi to denote literals corresponding to x i , i.e., xi ∈ {x i , ¬x i }. We say that xi is positive if xi = x i and negative if xi = ¬x i . A truth assignment α : X → {0, 1} is a mapping indicating for each atom its truth value. For xi ∈ Lit(X), let α( xi ) = α(x i ) if xi is positive and let α( xi ) = 1 − α(x i ) otherwise. We write α |= ϕ whenever α is a model of ϕ according to the usual semantics of propositional logic (Van Dalen, 2013).
In the context of JA, the atoms in X represent propositions an agent may either accept or reject. A judgment J is a set J ⊆ X, indicating which propositions are accepted. Let aug(J) = J ∪ {¬x | x ∈ X \ J} be the judgment J augmented with the negative literals of the propositions not selected. Observe that a judgment J can be equivalently described as the truth assignment α such that α(x) = 1 if and only if x ∈ J. In our examples, when we do not explicitly specify the status of some of the propositions, it is assumed that we only consider judgments (and truth assignments) for which the unspecified propositions are rejected (mapped to 0).
An integrity constraint Γ ∈ L X is a formula used to constrain the range of admissible judgments. A judgment J satisfies Γ (written J |= Γ), if J, interpreted as a truth assignment, is a model of Γ. Such a judgment J is then said to be admissible. Let J(Γ) = {J ⊆ X | J |= Γ} be the set of all admissible judgments for any Γ ∈ L X . A problem instance for JA is simply an integrity constraint Γ.
We again use N = {1, . . . , n} to denote the set of agents. Each agent i ∈ N provides us with a judgment J i , resulting in a judgment profile J = (J 1 , . . . , J n ). For a profile J and a literal ∈ Lit(X), we write n J = i∈N 1 ∈aug(Ji) for the number of supporters of . The majoritarian outcome for a profile, denoted by m(·), is the set of literals supported by a (strict) majority of agents: A JA rule is a function F : L X × (2 X ) n → 2 2 X \ {∅} taking as input an integrity constraint Γ and a judgment profile J and returning a nonempty set F (Γ, J ) ⊆ J(Γ) of admissible judgments. Observe that no assumption is made about the profile. In particular, we do not require J i |= Γ for any of the agents i ∈ N .
Before reviewing a number of well-known concrete JA rules, let us first introduce a very general class of such rules.
Definition 1 (Additive rules) A JA rule F is an additive rule if there exists a function f : (2 X ) n × Lit(X) → R mapping pairs of profiles and literals to real values, such that, for every integrity constraint Γ ∈ L X and every profile J ∈ (2 X ) n , we have: This class generalises both the scoring rules of Dietrich (2014) and the additive majority rules (AMRs) defined by Nehring and Pivato (2019). More specifically, a scoring rule is associated with a scoring function s : 2 X × Lit(X) → R mapping judgments and literals to scores, and corresponds to the additive rule defined with respect to the function f such that: An AMR is associated with a non-decreasing gain function g : {0, . . . , n} → R with g(k) < g(k ) for any k < n 2 ≤ k that maps the support of a literal to a PB profile A PB instance I ∈ I Feasible budget allocation π ∈ A(I) score, and is an additive rule defined with respect to the function f such that: Three additive rules are of particular importance for our purposes: • The Slater rule (Miller and Osherson, 2009;Lang et al., 2011) selects the admissible outcome closest to the majoritarian outcome in terms of the number of propositions they agree on. It is the AMR associated with the following gain function g: • The Kemeny rule (Pigozzi, 2006;Miller and Osherson, 2009) selects the feasible outcome that is the closest to the profile as a whole. It is both an AMR with the gain function g(x) = x, and a scoring rule with the scoring function s(J, ) = 1 ∈aug(J) . • The leximax rule (Everaere et al., 2014;Nehring and Pivato, 2019) favours the propositions supported by the largest majorities. It is the AMR defined by the gain function g(x) = |X| x .
Note that the three rules presented above are all majority-consistent, meaning that whenever the majoritarian outcome is admissible, it is the unique judgement returned by the rules.

Embedding PB into JA
The aim of this paper is to design rules to decide on outcomes for PB problems.
To this end, we want to embed PB into JA and then use JA rules to compute budget allocations. A full schematic representation of the process is presented in Figure 1. For a given PB instance, we introduce one proposition for each project to obtain X. So we have a direct correspondence between budget allocations π ⊆ P and judgments J ⊆ X, and thus also between PB profiles and JA profiles. Similarly, any JA outcome can be translated back into the PB setting.
Definition 2 (Outcome translation) Let I = R, b, P, c be a PB instance and let Γ ∈ L X be an integrity constraint expressed over the atoms X = {xp | p ∈ P}. The outcome translation τ : 2 X → 2 P maps any judgment J ∈ 2 X to a budget allocation π = τ (J) such that: We moreover extend the outcome translation to sets J ⊆ 2 X of judgments by stipulating that τ (J ) = {τ (J) | J ∈ J }. We now define one of the fundamental elements of our approach: embeddings. An embedding is a function E : I → L X that takes a PB instance as input and returns an integrity constraint (i.e., a JA instance). Given an embedding, we can translate any input of a PB rule into an input for a JA rule, apply the JA rule, and finally translate the result obtained into a set of budget allocations (see Figure 1). However, to be meaningful, the integrity constraint should express the budget constraint of the PB instance. This is captured by the notion of correctness that states that the outcome translation τ defines a bijection between the set of budget allocations on the PB side and the set of admissible judgments on the JA side.
Definition 3 (Correct embedding) An embedding E : I → L X is said to be correct if, for every PB instance I ∈ I, we have: τ (J(E(I))) = A(I).

Efficient Embeddings
In this section we present specific embeddings of enriched PB instances into JA. Given that the problem of computing outcomes for the JA rules defined in Section 2.2 is known to be highly intractable in general , if we nevertheless want to design PB rules that are tractable, we need to ensure that PB instances are mapped into JA instances that permit efficient outcome determination. To this end, we first present a class of Boolean functions (to encode integrity constraints) for which the outcome determination can be solved efficiently.

Tractable Language for Judgment Aggregation
As shown by De Haan (2018), computing outcomes under Kemeny and Slater can be done efficiently when the integrity constraint is a Boolean circuit in decomposable negation normal form (DNNF). We are going to extend this result to all additive rules. But let us first recall the definition of a DNNF circuit (Darwiche and Marquis, 2002). Fig. 2 Example of a decomposable negation normal form (DNNF) circuit.
Definition 4 (DNNF circuits) A circuit in negation normal form (NNF) is a rooted directed acyclic graph whose leaves are labelled with , ⊥, x or ¬x, for x ∈ X and whose internal nodes are labelled with ∧ or ∨. A DNNF circuit C is an NNF circuit that is decomposable in the sense that, for every conjunction in C, no two conjuncts share a common propositional atom. Figure 2 shows an example for a DNNF circuit. It can easily be checked that no two conjuncts share a common propositional atom. For a given JA rule F , we define the outcome determination problem as the following decision problem:

Outcome(F )
Input: An integrity constraint Γ, a judgment profile J , and a subset of literals L ⊆ Lit(X). Question: Is there a J ∈ F (Γ, J ) such that L ⊆ aug(J)?
We now show that for most additive JA rules F we can solve Outcome(F ) efficiently when Γ is given as a DNNF circuit. The result does not apply to all additive rules, but only to those for which the associated function f does not require expensive computation. This is captured by the notion of polynomialtime computable functions, i.e., functions for which there exists an algorithm computing the outcome of the function and running in time that is polynomial in the size of the input.
Theorem 1 Let F be an additive JA rule defined with respect to some polynomialtime computable function f . Then Outcome(F ) is polynomial-time solvable when the integrity constraint Γ in the input is represented as a DNNF circuit.
Proof We show that when Γ is a DNNF circuit, we can use the Algebraic Model Counting (AMC) problem to solve Outcome(F ). Given a propositional formula ϕ ∈ L X , a commutative semi-ring A, ⊕, ⊗, e ⊕ , e ⊗ , 4 and a labeling function λ : 4 A semi-ring A, ⊕, ⊗, e ⊕ , e ⊗ is an algebraic structure such that ⊕ and ⊗ are associative binary operations over A; ⊕ is commutative; e ⊕ is the identity element of ⊕ and e ⊗ that of ⊗; ⊗ is left and right distributive over ⊕; and finally e ⊕ ⊗ a = a ⊗ e ⊕ = e ⊕ for any a ∈ A. A semi-ring is commutative if ⊗ is commutative too.
Lit(X) → A, the AMC problem is to compute: The pair ⊕, λ is called neutral if and only for every propositional atom x ∈ X, Kimmig et al. (2017) proved that when ϕ is a DNNF circuit, ⊕ is idempotent, 5 and ⊕, λ is neutral, then the AMC problem can be solved in polynomial time.
We now show that Outcome(F ) can be solved using the AMC problem when F is an additive rule. Consider the max-plus algebra-a commutative and idempotent semi-ring (Akian et al., 2006)-defined by A = R∪{−∞, ∞}, e ⊕ = −∞, and e ⊗ = 0, where ⊕ and ⊗ are the usual max and + operators over R ∪ {−∞, ∞}.
Consider now an additive JA rule F associated with f . For a profile J we introduce a labelling function λ J (·) defined as follows for every literal x ∈ Lit(X) of the atom x ∈ X: where f is the function with respect to which F is an additive rule.
Since we have max(λ J (x), λ J (¬x)) = 0 for every x ∈ X, it is easy to see that the pair λ J , ⊕ = λ J , max is neutral.
For every such labelling function, we then have: Let us briefly explain the computations above. The transition between lines (1) and (2) comes from the fact that aug(J) include exactly one literal for each propositional atom in X. Observe then that 2 × x∈X max (f (J , x), f (J , ¬x)) does not depend on the J over which the argmax loops, and can thus be dropped. We can then solve Outcome(F ) by using the AMC problem. For Γ, J and L ⊆ Lit(X) given as inputs of the Outcome(F ) problem, we will solve the AMC problem twice: first for ϕ = Γ and then for ϕ = Γ , where Γ is obtained from Γ by fixing the value of the atoms as in L. If the solution of the AMC problem is the same in both cases, we answer the Outcome(F ) problem by the positive.
To conclude the proof, observe that the pair max, λ is neutral. Thus, the AMC problem can be solved in polynomial time when ϕ is a DNNF circuit (Kimmig et al., 2017). Hence, the Outcome(F ) problem can also be solved in polynomial time when Γ is a DNNF circuit.
This general result immediately implies tractability of outcome determination for the rules we are interested in here and will allow us to use these rules to compute budget allocations for PB instances embedded into JA.
Corollary 2 When the integrity constraint is represented as a DNNF circuit, then the problem Outcome(F ) can be solved in polynomial time when F is either the Kemeny, the Slater, or the leximax rule.

DNNF Circuit Embeddings
At this point we know that we can efficiently compute the outcome of JA rules when the integrity constraint is represented as a DNNF circuit, but we still need to demonstrate that it in fact is possible to encode PB problems as integrity constraints of this kind. So we move on to the description of embeddings of PB into JA returning integrity constraints represented as DNNF circuits. In doing so, we follow De Haan (2018) but use a slight generalisation of his approach, allowing us to deal with PB instances with multiple resources.
The basic idea is that every ∨-node in the DNNF circuit will represent the choice of selecting (or not) a given project. To know whether it is possible to select a given project, we keep track of the amount of resources that has been used so far. Selecting a project can thus only be done if it would not lead to a violation of the budget constraint.
For a project index j and a vector of used quantities per resources v ∈ R d ≥0 , we introduce the ∨-node N (j, v), corresponding to the situation where we previously made a choice on projects with indices 1 to j − 1, and where for these choices we used resources according to v. These nodes N (j, v) are defined as follows: For a PB instance I = R, b, P, c , the tractable embedding TE(I) returns the integrity constraint defined by N (1, 0 d ), where 0 d denotes the vector of length d whose components are all equal to 0. Let us illustrate this embedding on a simple example.
Example 1 Consider an instance I with just one resource r and projects p 1 , p 2 , and p 3 . The cost of the projects in r is c(p 1 ) = c(p 2 ) = 1 and c(p 3 ) = 2 and the budget limit is b = 2. Call xp 1 , xp 2 , and xp 3 the propositional atoms corresponding to p 1 , p 2 , and p 3 , respectively. TE on I would construct the DNNF circuit presented in Figure  3. Note that we simplified the DNNF circuit a bit to improve its readability. We can show that the tractable embedding does encode PB instances correctly.
Proposition 3 The tractable embedding TE is correct, and for any given PB instance I = R, b, P, c returns an integrity constraint TE(I) represented as a DNNF circuit of size in O(m × |{c(π) | π ⊆ A(I)}|).
Proof Let I = R, b, P, c be a PB instance, and Γ an integrity constraint such that Γ = TE(I).
We first show that Γ is represented as DNNF circuit. First, observe that Γ is a Boolean circuit rooted in N (0, 0 d ). Next, observe that every ∨-node is of the form (x ∧ β 1 ) ∨ (¬x ∧ β 2 ), where x ∈ X is a propositional atom and β 1 , β 2 are either ∨nodes, ⊥, or . This implies that Γ is represented as an NNF circuit. Because each project is only considered once, the propositional atom corresponding to the project cannot appear in two distinct conjuncts. Hence, Γ is a DNNF circuit.
Observe that there are at most m × |{c(π) | π ⊆ A(I)}| ∨-nodes in Γ-one for each N (j, v) for which the budget is not exceeded-all of them having at most two child ∧-nodes. There are moreover 2m + 2 leaves, one per literal and two for ⊥ and , hence the size of the DNNF circuit. We now show that the tractable embedding is correct. Observe that a branch leading to the ⊥-leaf is chosen if and only if one would violate the budget limit by selecting a project p j . Hence, finding an assignment that does not lead to a ⊥ leaf in Γ can only be done by selecting feasible projects. The set of such assignments defines the set of outcomes satisfying Γ, so τ (E(I)) ⊆ A(I). Now, consider π ∈ A(I).
Since π is feasible, it is clear that there exists a branch in the DNNF circuit Γ along which the selected projects correspond exactly to those that are in π. We thus have τ (E(I)) = A(I).
At this point, it should be noted that the exponential factor in the size of the embedding, namely |{c(π) | π ⊆ A(I)}|, is bounded from above by the product of the budget limits for each resource. Hence, the corresponding DNNF circuit is of size in O(m × r∈R b r ). This is pseudo-polynomial in the size of the PB instance when the number of resources is fixed. The next natural question then is whether we can do better. For instance, is it possible to reduce the size to something pseudo-polynomial in the size of the PB instance regardless of the number of resources, i.e., in O(m × r∈R b r )? The following result answers this question in the negative.
Proposition 4 There exists no embedding into a DNNF circuit that can be computed in time polynomial in m + r∈R br for any instance I = R, b, P, c , unless P = NP.
Proof We first show that the following problem is strongly NP-complete.

Maximal Exhaustive Allocation
Input: A PB instance I and a natural number k ∈ N Question: Is there a π ∈ A EX (I) such that |π| ≥ k?
First, note that Maximal Exhaustive Allocation obviously is in NP, given that checking that a budget allocation is exhaustive and selects at least k projects is just a matter of looping through all the projects of the instance.
We now show that Maximal Exhaustive Allocation is strongly NP-hard. To do so we reduce from the 3-dimensional Matching problem, which was shown to be NP-complete by Karp (1972). Note that, since its input does not involve numbers, the 3-dimensional Matching problem is immediately also strongly NP-complete.

3-dimensional Matching
Input: A finite set T and a set X ⊆ T × T × T Question: Is there a set M ⊆ X such that |M | = |X|, and for all (x 1 , x 2 , x 3 ) and (y 1 , y 2 , y 3 ) in M , we have x 1 = y 1 and x 2 = y 2 and x 3 = y 3 ?
Consider, without loss of generality, an instance of the 3-dimensional Matching problem T, X such that T = {1, . . . , t} and , 2, 3}} and for every resource r ∈ R, we have br = 1. The set of projects is x 2 i and r 3 x 3 i and 0 for any other resource. Moreover we set k = |X|. We claim that the answer for the 3-dimensional Matching problem on T, X is yes if and only if the answer for the Maximal Exhaustive Allocation problem on I, k is yes too.
To a matching M ⊆ X corresponds the budget allocation π = {p i | x i ∈ M }. A matching M ⊆ X is a solution of the 3-dimensional Matching problem if and only if no triplet in M share a coordinate. Because of the budget limit, this is possible if and only if the corresponding budget allocation π is feasible. Moreover |M | = |X| if and only if |π| = |X| = k. Note that in this case π would be exhaustive, which proves the claim. The reduction is clearly done in polynomial time which shows that the Maximal Exhaustive Allocation problem is strongly NP-complete.
To conclude the proof, we now show that, if there exists an embedding of PB into a DNNF circuit of size polynomial in m + r∈R br, then we would be able to solve the Maximal Exhaustive Allocation problem in pseudo-polynomial time, which would imply that P = NP.
Let us prove that last claim. Let Γ be the integrity constraint returned by a suitable exhaustive embedding on an arbitrary instance I. Note that the answer to Maximal Exhaustive Allocation problem is yes if and only if the outcome of the Algebraic Model Counting (AMC) problem is at least k − m when run on Γ with the max-plus algebra (see the proof of Theorem 1 for the definitions) and the labeling function λ such that λ(x) = 0 and λ(¬x) = −1 for all x ∈ X. Since Γ is a DNNF circuit and the pair λ, ⊕ is neutral, we can compute the outcome of the AMC problem in polynomial, proving the claim.
Even though there is no hope to find pseudo-polynomial embeddings when the number of resources is unbounded, we still argue that the embedding is efficient for realistic scenarios. First in most typical PB processes, the number of resources would likely be small. Indeed the difficulty of assessing the different costs and of the deliberation and voting processes increases significantly with the number of dimensions. It thus seems particularly unlikely that the cost will be expressed in more than, say, five dimensions. Moreover, if the number of resources is fixed, or at least bounded, the size of the DNNF circuit will not really present a serious limitation with state-of-the-art solvers.
In the remainder of this section we investigate to what extent this approach allows us to introduce additional distributional constraints for PB.

Dependencies between Projects
We now consider the situation where the completion of some projects is directly dependent on the completion of some others.
Take a PB instance I = R, b, P, c . We introduce a set of implications, Imp ⊆ L X , linking projects together. A set of implications is a set of propositional formulas of the form xp → x p for p and p that are two projects in P, with xp and x p being the corresponding literals. Note that this corresponds to 2-CNF formulas. In the case that xp is positive (resp. negative), such an implication indicates that p can be selected (resp. cannot be selected) only if p is selected, when x p is positive, or not selected, when x p is negative. A budget allocation π satisfies the set of implications Imp if and only if the previously described semantics is satisfied. Moreover, we will write xp → * x p if there is a chain of implication in Imp linking xp to x p .
In terms of applications, this approach to model dependencies is quite flexible. For instance, it allows us to model the fact that project p 1 can only be implemented if projects p 2 and p 3 would also be implemented. This would be encoded as Imp = {x p1 → x p2 , x p1 → x p3 }. At the same time, we can also model "negative" dependencies, or "incompatibilities", where p 1 can only be implemented if p 2 is not: Imp = {x p1 → ¬x p2 }. We are not aware of any previous work that would allow for such constraints to be expressed within the PB framework. Note though that one can implement dependencies of the type x p → ¬x p by having specific budget constraints over categories over project as done by Jain et al. (2021).
To start our analysis, we show that finding a feasible budget allocation when there are implications between project is an NP-complete problem.
Proposition 5 Let I = R, b, P, c be a PB instance and Imp a set of implications over I. Deciding whether there exists a feasible budget allocation for I satisfying Imp is NP-complete, and NP-hardness holds even for the case of a single resource.
Proof The problem of finding a feasible budget allocation satisfying Imp is clearly in NP. Indeed, checking that the budget limit is not exceeded can be done by summing the costs of the selected projects. Moreover, verifying that the set of implications is satisfied simply amounts at checking the truth value of each implication in Imp.
Both of these problems can be solved in polynomial time.
To show that the problem is NP-hard, we reduce from the NP-complete problem 2-CNF Minimal Model 6 (Ben-Eliyahu and Dechter, 1996).

2-CNF Minimal Model
Input: A formula ϕ ∈ L X in conjunctive normal form with exactly two literals per clauses and k ∈ N. Question: Is there a model α such that α |= ϕ and |{p ∈ X | α(p) = 1}| ≤ k?
Take an instance ϕ, k of the 2-CNF Minimal Model problem. We construct the following participatory budgeting instance I. The set of resources is R = {r} with budget limit br = k. There is one project per propositional atom in ϕ, P = {px | x ∈ P }, and c(p) = 1 for every p ∈ P. Finally, the set of implications Imp is the set of clauses in ϕ. We claim that there exists a model of ϕ setting no more than k variables to true if and only if there exists a feasible budget allocation for I that satisfies the set of implications Imp. Indeed, to a given truth assignment α, corresponds the budget allocation π = {px | α(x) = 1}. Observe first that there exists α |= ϕ if and only if π satisfies Imp. Moreover, since every project is of cost 1, the cost of π is exactly the number of project that are selected. As the set of projects is the set of variables in ϕ, the cost of π is also equal to the number of variables set to true in α. Because the budget limit for resource r is k, the budget allocation π satisfies the budget limit if and only no more than k propositional atoms are set to true in α.
Observing that this reduction clearly can be done in polynomial time concludes the proof.
Based on this result, we cannot hope to find an embedding into a DNNF circuit of polynomial size. However, we can still define an interesting embedding the size of which is parameterized by some parameter on the structure of the implication set (in the spirit of parameterized complexity (Downey and Fellows, 2013)). The parameter in question is the pathwidth (Robertson and Seymour, 1983;Bodlaender, 1998) of the interconnection graph. Let us define these two terms.
First, we introduce the interconnection graph G of a set of implications Imp. It is the graph G = P, E where there is an edge {p, p } ∈ E between projects p and p if and only if there exists an implication in Imp linking the two projects, i.e., Imp includes at least one implication of the form xp → x p for some xp ∈ {x p , ¬x p }, x p ∈ {x p , ¬x p }.
Second, let us discuss the pathwidth of a graph G = V, E . A pathdecomposition of a graph G is a vector of subset of vertices (V 1 , . . . , V q ), called bags, such that: (i) for every edge ( The second property should be understood as saying that the set of bags in which a given vertex appears is contiguous. The width of a tree decomposition is the size of the largest bag minus one. The pathwidth of a graph G is the minimum width of any of its path-decomposition.
We are now equipped with all the definitions we need to formulate our embedding for dependencies, denoted by TE dep .
Theorem 6 Let I = R, b, P, c be a PB instance and Imp a set of implications over I. Then there exists a correct embedding from I and Imp to an integrity constraint expressed as a DNNF circuit Γ with size in O m × |{c(π) | π ⊆ A(I)}| × 2 k , where k is the pathwidth of the interconnection graph of Imp.
Proof The proof will be presented in several steps. We will first present our embedding TE dep , then investigate the size of the integrity constraint returned and finally show that the embedding is correct. In the following we assume that X is exactly the set {xp | p ∈ P}.
Let G = P, E be the interconnection graph of Imp. We order the projects in the same order in which they are introduced in an optimal path-decomposition of G. Then, following the idea developed for TE, we introduce ∨-nodes N (j, v, L) where j is a project index, v ∈ R d ≥0 a vector of used quantities per resource and L ⊆ Lit(X) a subset of literals. Intuitively, the set L specifies the literals that we selected and that we should remember because they might trigger implications later on. The nodes N (j, v, L) are then defined such that: • If j = m + 1, then N (j, v, L) = ; • If both the positive literal xp j and the negative literal ¬xp j are implied by some literal in L according to Imp, then N (j, v, L) = ⊥; • If the positive literal xp j is implied by some literal in L according to Imp, and v + c(p j ) ≤ b, then N (j, v, L) = N (j + 1, v + c(p j ), L ∪ {xp j }); • If the positive literal xp j is implied by some literal in L according to Imp, but there exists a resource rq ∈ R such that vq + c(p j , rq) > bq, then N (j, v, L) = ⊥; • If the negative literal ¬xp j is implied by some literal in L according to Imp, The tractable embedding with dependencies, written TE dep , refers to the integrity constraint defined by N (j, 0m, ∅).
It is clear that the integrity constraint returned by the embedding described above is represented as a DNNF circuit. The proof is very similar to the one for the tractable embedding (Proposition 3).
We now investigate the maximum size of the DNNF circuit. We need to count the maximum number of ∨-nodes, that is the number of N (j, v, L). At a first glance, the number of possible L ⊆ Lit(X) is upper-bounded by 2 |P| . However, we can have a more fine-grained analysis of this last term. The set L is used to keep track of the projects for which a truth value has already been assigned and that could imply the truth value of some other project appearing later in the ordering. However, since the projects are considered following an optimal path-decomposition of the interconnection graph, we know that we never need to remember the truth value of more than k + 1 projects, where k is the pathwidth of the interconnection graph. Indeed, by definition of a path-decomposition, for any project p j , whenever we consider another project p j such that p j never appears in a bag together with p j , we no longer need to keep track of the truth value associated with xp j as p j will never be involved in implications with subsequent projects. Overall, the size of the DNNF circuit is in O m × |{c(P ) | P ⊆ P}| × 2 k .
Finally, we show that TE dep is correct. Remember that this is the case if for every instance I: {τ (J) | J ∈ J(TE dep (I, Imp))} = A(I, Imp).
Consider a JA outcome J ∈ J(TE dep (I, Imp)). It is clear that τ (J) does not exceed the budget limit as every were selecting a project could lead to a too high cost, the branch in the DNNF circuit ends up in the ⊥ leaf. We then need to prove that τ (J) satisfies Imp. Observe that every time a literal is implied by a literal that has been previously given a truth value, we follow the implication. Hence it can never be the case that the premise of an implication is set to true but not the conclusion. Moreover, every time triggering implications would lead to an inconsistent outcome (a project being both selected and not selected), the branch in the DNNF circuit also leads to the ⊥ leaf. Overall τ (J) does satisfy Imp. We have thus proved that {τ (J) | J ∈ J(TE dep (I, Imp))} ⊆ A(I, Imp). The proof for the reversed inclusion is exactly as that presented in Proposition 3.
The size of the DNNF circuit produced by the embedding includes a factor 2 k , where k is the pathwidth of the interconnection graph of Imp. The value of k is in general upper-bounded by the number of projects, for instance in the case where the interconnection graph is complete (when there are dependencies between any two projects). Once again, it seems fair to assume projects not to be very interconnected, leading to small values of k in practice.
x p3 ⊥ Let us illustrate the embedding used in the proof on an example.
Example 2 Consider the instance described in Example 1. Assume that, if project p 1 is selected, then also project p 2 should be selected. In our model, this means that Imp = {xp 1 → xp 2 }. An optimal path-decomposition of the interconnection graph is thus ({p 1 , p 2 }, {p 3 }). So we will consider the projects in the following order: p 1 , p 2 , p 3 . The embedding TE dep would return the DNNF circuit presented in Figure 4. It is important to understand how we can "forget" about the truth values of xp 1 and xp 2 once we consider project p 3 .
We conclude this section with a small detour into the field of Knowledge Compilation (see, e.g., Marquis, 2015). Embedding PB problems with dependencies into a DNNF circuit is actually equivalent to asking whether the conjunction of a 2-CNF formula with a DNNF circuit can be efficiently encoded as a DNNF circuit of polynomial size. It turns out to be impossible to do so unless the polynomial hierarchy collapses.
Proposition 7 A 2-CNF formula ϕ ∈ L X cannot be compiled into a DNNF circuit of size polynomial in the size of ϕ unless the polynomial hierarchy collapses to the second level.
Proof We will prove that if 2-CNF formulas can be compiled into polynomial-size DNNF circuits, then the NP-complete problem Clique would be in P/poly, using similar techniques as Cadoli et al. (2002). Because of the Karp-Lipton theorem (Karp and Lipton, 1980), this would immediately entail the Polynomial Hierarchy to collapse at the second level.
Let us first introduce the problem Clique shown to be NP-complete by Karp (1972). Given an undirected graph G = V, E , we say that a subset of vertices V ⊆ V forms a clique in G if for every v 1 , v 2 ∈ V , we have {v 1 , v 2 } ∈ E. The decision problem Clique is then defined as follows.

Clique
Input: An undirected graph G = V, E and an integer k ∈ N. Question: Is there a clique V ⊆ V such that |V | = k in G?
For any two integers n, k ∈ N, we introduce a 2-CNF formula ϕ(n, k) such that the answer of Clique on a graph G = V, E with |V | = n and k can be deduced by means of queries of the following problem the we call Max SAT Extension: Given a partial truth assignment α of ϕ, what is the maximum number of variables that can be set to true in any extension of α in such a way that α satisfies ϕ(n, k). Importantly, the formula ϕ(n, k) is the same for all graphs with n vertices and inquired clique size k. In the following we will assume that the vertices in V are named v 1 , . . . , vn.
Let us describe how to construct ϕ(n, k). For every i, i ∈ {1, . . . , n} and each 1 ≤ j < j ≤ k, we introduce the variable x j,j ,i,i . The idea of these variables is to indicate which vertex was selected at a given position in an arbitrary ordering of the clique. So having x j,j ,i,i set to true means that in the ordering of the clique in which vertex v i is at position j, then vertex v i is at position j . Now for this to be correct, we need to enforce that no two vertices can be selected at the same position. For every j 1 , j 2 , j 3 , j 4 ∈ {1, . . . , k} such that j 1 < j 2 , j 1 < j 3 and j 4 < j 2 , and for every i 1 , i 2 , i 3 , i 4 ∈ {1, . . . , n}, we thus add the following two clauses to the formula ϕ(n, k): (¬x j1,j2,i1,i2 ∨ ¬x j1,j3,i3,i4 ) (¬x j1,j2,i1,i2 ∨ ¬x j4,j2,i3,i4 ) Now, we want to check whether any given graph G = V, E with |V | = n has a clique of size k. Consider the formula ϕ(n, k). We first create a partial truth assignment α that sets x j,j ,i,i and x j,j ,i ,i to false for all 1 ≤ j < j ≤ k and all i, i ∈ {1, . . . , n} such that {v i , v i } / ∈ E. Now it is easy to see that G has a clique of size k if and only if we can extend this α to a (non-partial) truth assignment that satisfies ϕ(n, k) and that sets at least k(k − 1)/2 variables to true.
At this point, it is important to observe that the problem Max SAT Extension can be solved in polynomial time if the formula provided is a DNNF circuit. It is a simple variant of the Maximum Model problem that we can solve via dynamic programming on DNNF circuits. Now, suppose we can compile 2-CNF formulas into DNNF circuits in polynomialspace, then we compile ϕ(n, k) into a DNNF for each n and each k. Call this DNNF circuit D(n, k). From the above, it should be clear now that with D(n, k) we can solve the Clique problem on a graph G with n nodes and an inquired clique size of k in polynomial time.
To conclude the proof we show that this would then all mean that Clique is in P/poly. We first informally define P/poly, we refer the reader to Chapter 6 in the book by Arora and Barak (2009) for a formal definition. P/poly is a complexity class that contains problems that can be solved in polynomial time by a deterministic Turing machine that has access to one advice string per size of the input. In our case, the advice string for an input of size n will be the sequence (D(n, 1), . . . , D(n, n)). Note that the size of the advice string is polynomial in n as each DNNF circuit in it is. For any input of Clique, we can then find the corresponding DNNF circuit D(n, k) to solve the problem in polynomial time. This proves that Clique would be in P/poly, and so that NP ⊆ P/poly (since Clique is NP-complete). The Karp-Lipton Theorem (Karp and Lipton, 1980) then immediately implies that the polynomial hierarchy would collapse to the second level.
We already knew that there was little hope for a DNNF circuit encoding of PB instances with dependencies in polynomial-time (unless P = NP). Under a stronger computational complexity assumption, we now have gone further by showing that it is also unlikely to be able to do this in polynomial space.

Quotas on Types of Projects
The second extension of PB we consider is when projects are grouped into categories, or types, that are constrained by quotas. 7 The idea is that the projects belong to various types (health, education, environment to name a few) and that certain quotas over these types are to be respected by the final budget allocation (at least two health-related projects must be funded, for instance). We model this idea by defining a type system.
Let us now define what a type system is. For a given PB instance I = R, b, P, c , a type system is a tuple T , Q, q, f , where: • T ∈ 2 2 P is a set of types, each type being a subset of projects; • Q = Q, ⊕, e ⊕ , ≤ Q is an ordered group 8 over which the quotas are expressed; • q : T → Q 2 is a quota function such that for any type t ∈ T , q(t) = (a, b) ∈ Q 2 with a ≤ Q b; • f : T × A(I) → Q is a type aggregator.
For any T ∈ T such that q(T ) = (a, b), we write q(T ) − = a and q(T ) + = b, which indicate the lower and upper quota for type T respectively. A budget allocation π is feasible if the quotas are respected-that is, if and only if for every type T ∈ T , we have q(T ) − ≤ Q f (T, π) ≤ Q q(T ) + .
The type aggregator f (·) can be defined in several different ways. We provide two type aggregators that are very natural.
• Cardinality-type aggregator. The quotas express lower and upper bounds on the number of projects selected for each type. We have Q = N, ⊕ is the usual addition operator on numbers with identity element 0, and ≤ Q is the usual linear order on numbers. Now for every type T ∈ T and budget 7 After our initial work on this topic (Rey et al., 2020), Jain et al. (2021) studied a specific subcase of our model, namely PB instances in which projects are grouped into categories and quotas regarding the total cost of projects from within each category need to be satisfied. There is a small overlap between the two papers: Proposition 8 in this section is implied by Theorem 10 of Jain et al. (2021). Other results are incomparable and the two papers nicely complement one another.
8 A group Q, ⊕, e ⊕ is an algebraic structure equipped with a binary operation ⊕ over Q that is associative, that has an identity element e ⊕ , and such that for every a ∈ Q, there exists a unique b ∈ Q such that a ⊕ b = e ⊕ and b ⊕ a = e ⊕ . An ordered group Q, ⊕, e ⊕ , ≤ Q is a group Q, ⊕, e ⊕ equipped with a total order ≤ Q over Q.
• Cost-type aggregator. The quotas define lower and upper bounds on the total cost of the projects selected for each type. Here Q = R d ≥0 , ⊕ is the component-wise addition over vectors with identity element 0 d , and ≤ Q is the component-wise order over vectors. 9 Now for every type T ∈ T and budget allocation π, the cost-type aggregator is defined as follows: We first show that deciding whether there is a feasible budget allocation with a given type system is NP-complete, for both the cardinality-and the cost-type aggregator.
Proposition 8 Let I = R, b, P, c be a PB instance and T , Q, q, f a type system over I. Deciding whether there exists a feasible budget allocation π is NP-complete when f is either the cardinality or the cost-type aggregator, and NP-hardness holds even for a single resource.
Proof The problem is clearly in NP. Indeed, verifying that the budget allocation π does not exceed the budget limit can be done easily by summing the costs of the selected projects. Note that both the cardinality-and the cost-type aggregators can be computed in polynomial time. Then, verifying that every quota is respected is just a matter of scanning π for each quota.
Let us show now that the problem is NP-hard. To do so we reduce from the NP-hard Set Splitting problem (Garey and Johnson, 1979) described below.

Set Splitting
Input: A collection C of subsets of a given set S. Question: Are there two sets S 1 and S 2 partitioning S such that ∀c ∈ C, c S 1 and c S 2 ?
Let C, S be an instance of Set Splitting. We construct a participatory budgeting instance I = R, b, P, c such that R = {r}, and br = |S|. There is one project per element in S, P = {ps | s ∈ S}, and c(ps) = 1 for every s ∈ S. Thus, the budget limit can never be exceeded. The corresponding set of types is T = {{ps | s ∈ c} | c ∈ C} and for a given T ∈ T , the quota is q(T ) = (1, |T | − 1). With one resource and projects whose costs are in {0, 1}, the cardinality-type aggregator and the cost-type aggregator coincide.
We claim that C, S is a yes-instance of Set Splitting if and only if there exists a feasible budget allocation in the instance I with the previous type system. For a given partition of S, (S 1 , S 2 ), a suitable corresponding budget allocation is π = S 1 (or equivalently π = S 2 ).
A partition (S 1 , S 2 ) is a solution of the Set Splitting problem if and only if for every c ∈ C, at least one element of c is in S 1 and at least one element of c is not in S 1 (and is then in S 2 ). Based on the type system we defined, this is equivalent to π satisfying the quota associated to c. Moreover, observe that every budget allocation respects the budget limit. Hence (S 1 , S 2 ) is a solution of the Set Splitting problem if and only if π is a feasible budget allocation.
The reduction is clearly done in polynomial time, hence the problem of finding whether a feasible budget allocation exists is NP-complete when using both the cost and the cardinality type aggregator.
Once again, this implies that no efficient embedding can be defined for this extension. In what follows we present a parameterized embedding for PB with types and quotas.
The embedding works for any additive type aggregator f : T × A(I) → Q, that is, any type aggregator f for which there exists a score type function s that takes as input a project p ∈ P and returns an element in Q such that for every type T ∈ T and every allocation π ∈ A(I): Note that both the cardinality-and the cost-type aggregators are additive, with s card (p) = 1 and s cost (p) = c(p) respectively.
As for the dependencies case, the size of our embedding will be parameterized by the pathwidth of a graph. This time, it will be the overlap graph of a type system. Let I be an instance and T , Q, q, f a type system over I, the overlap graph of the type system is the graph G = T , E , where there is an edge {T, T } ∈ E between types T and T if and only T ∩ T = ∅, i.e., T and T do not overlap.
We are now ready to present the embedding.
Theorem 9 Let I = R, b, P, c be a PB instance and T , Q, q, f a type system where f is an additive type aggregator defined with respect to the score type function s. Then there exists a correct embedding for I and T , Q, q, f that returns an integrity constraint represented as a DNNF circuit whose size is in and where k is the pathwidth of the overlap graph of T , Q, q, f .
Proof We use a similar strategy as for Theorem 6. The general idea is that because the type aggregator is additive, we can keep track of the current value of the quotas, and then, when deciding whether a project can be selected or not, we can check the current quota value before making our choice. Let G = P, E be the overlap graph of T , Q, q, f . We order the projects in the same order in which they are introduced in an optimal path-decomposition of G. As usual, we will then define the ∨-nodes N (j, v, q), where j is a project index, v ∈ R d ≥0 a vector of used resources and q ∈ Q |T | is a vector of current quota value. We introduce extra notation before defining them. Let Tp j = {T ∈ T | p j ∈ T } be the set of types containing project p j . For a given q ∈ Q |T | , define q pj such that q pj T = q T for every T / ∈ Tp j , and such that q pj T = q T ⊕ s(p j ) for every T ∈ Tp j . The ∨-nodes N (j, v, q) are then defined as follows: • If j = m + 1 we have N (j, v, q) = ; • If there are two types T 1 , T 2 ∈ Tp j such that p j is the last project in T 2 to be considered, and the quotas satisfy q pj T1 > Q q(T 1 ) + but q pj T2 < Q q(T 2 ) − , then N (j, v, q) = ⊥; • If there is a type T ∈ Tp j such that q pj T > Q q(T ) + , then: • If there is a type T ∈ Tp j such that p j is the last project from T to be considered and the quota over T satisfies q T < Q q(T ) − and q pj T < Q q(T ) − , then: • If there exists r ∈ R such that v + c(p j , r) > br, then: The tractable embedding for types and quotas, written TEquo , refers to the integrity constraint defined by N (1, 0m, 0 |T | ).
Similarly to the proof of Theorem 6, we can order the projects according to the ordering of types in a suitable path-decomposition of the overlap graph. By doing so, in each node N (j, v, q), we can "forget" all types in q for which we already considered all projects-thereby reducing the number of nodes N (j, v, q) for each j and v.
It is clear that TEquo returns an integrity constraint represented as a DNNF circuit. We now show that the size of DNNF circuit is in: where k is the path-width of the overlapping graph.
Let us begin by observing that the first two term of the product above are the same as for the other tractable embeddings presented before, we do not expend on them. Then, observe that a quota can take at most max T ∈T (|{f (T, π) | π ∈ A(I)}|) different values. Hence, each component of q can only have max T ∈T (|{f (T, π) | π ∈ A(I)}|) distinct values. Now, how do we get it to the power k and not |T | in the size of the DNNF circuit? The idea is similar to that of the proof of Theorem 6: Whenever all projects of a given type have been considered, the value of the corresponding quota will no longer change and we can thus "forget" about that type. Hence, the maximum number of types we need to keep track of their quota is upper bounded by k +1. That proves the claim about the size of the DNNF circuit. Once again, remember that we can use known FPT algorithm to find an optimal path-decomposition (Bodlaender and Kloks, 1996).
x p3 ⊥ We now show that the embedding is correct. Consider a JA outcome J ∈ J(TEquo (I, Imp)). It is clear from the two previous embeddings that τ (J) satisfies the budget constraint. Moreover, in TEquo , before considering any project, if the current value of a quota violate the quota constraint associated with it, the branch in the DNNF circuit ends up on the ⊥ leaf. Because the type aggregator is additive, we know that the quota values in v are the quota values of the corresponding budget allocation. Hence we have τ (j) ∈ A(I). We have thus proved that {τ (J) | J ∈ J(TE dep (I, Imp))} ⊆ A(I, Imp). The proof for the reversed inclusion is exactly as the one presented for the proof of Proposition 3.
Before discussing the size of the DNNF circuit produced by the embedding, we will present TE quo on an example.
Example 3 Consider the instance described in Example 1. Assume that, projects p 1 and p 2 are health-related projects and that no more than one should be selected. In terms of our model, this means that we are considering the type system {T }, N, +, 0, ≤ , q, f card , where T = {p 1 , p 2 } and q(T ) = (0, 1). An optimal path-decomposition of the overlap graph is thus ({p 1 , p 2 }, {p 3 }). So we will consider the projects in the following order: p 1 , p 2 , p 3 . The embedding TEquo would return the DNNF circuit presented in Figure 5. It is important to understand how we can "forget" about the truth values of xp 1 and xp 2 once we consider project p 3 .
Regarding the size of the DNNF circuit, it should be noted that the factor max T ∈T (|{f (T, π) | π ∈ A(I)}|) k+1 can be very high. However, for the cardinality and the cost-type aggregators, we can derive the following bounds: This in particular implies that the integrity constraint for these quota aggregators would be reasonable of reasonable size, as long as k, the pathwidth of the overlap graph, is small.
The question is then how small or large k can be. Of course, in principle, it can be as large as the number of projects. That is the case if all projects appear in all types. On the other hand, the pathwidth of the overlapping graph would be 0 in the case where the types are non-overlapping. This special case is actually very natural. For instance, if one takes types to represent distinct areas of a city that are to be developed, then no project concerning one area will also concern another area. We get the following result for non-overlapping types.
Corollary 10 Let I = R, b, P, c be a PB instance and T , Q, q, f a type system where f is an additive type aggregator defined over the score type function s. If the types are not overlapping, that is, if the overlapping graph of T , Q, q, f is the empty graph, the size of the integrity constraint returned by TEquo is in O (m × |{c(P ) | P ⊆ P}| × max T ∈T (|{f (T, π) | π ∈ A(I)}|)).

Enforcing Exhaustiveness
Amongst the most basic requirements of a budget allocation is that of exhaustiveness (Aziz et al., 2018), sometimes also referred to as budget monotonicity (Talmon and Faliszewski, 2019). It states that the budget should be used as much as possible. This property is crucial for PB, given that it is usually assumed that achieving a project is always better than not achieving it. We first recall the definition.
Definition 5 (Exhaustiveness) Given a PB instance I = R, b, P, c , a budget allocation π ∈ A(I) is said to be exhaustive if, for every project p ∈ P \ π, there exists at least one resource r ∈ R such that c(π ∪ {p}, r) > br.
Let us extend this definition to rules and embeddings. Remember that A EX (I) is the set of feasible and exhaustive budget allocations for an instance I. An embedding E : I → L X is said to be exhaustive if, for every instance I ∈ I, we have τ (J(E(I))) ⊆ A EX (I). On the other hand, an exhaustive embedding E is correct if A EX (I) = τ (J(E(I))) for every instance I. Finally, a JA rule F is said to be exhaustive if for every correct embedding E, every instance I ∈ I and every profile A, it is the case that τ (F (E(I), A)) ⊆ A EX (I). Similarly, a PB rule is said to be exhaustive if it only returns exhaustive budget allocations.
Because the scenarios typically modelled using JA are rather different from PB, the exhaustiveness axiom is not satisfied by common JA rules. Indeed, JA rules are usually designed to be majority-consistent-they would always return the majoritarian outcome if it is admissible-which is incompatible with exhaustiveness. This has to do with the semantics of rejection (of a proposition) in the context of JA.
Proposition 11 No majority-consistent JA rule is exhaustive.
Proof Consider a correct but not exhaustive embedding E (for instance TE as defined above). As E is not exhaustive, there exists a PB instance I such that there is at least one admissible JA outcome J ∈ J(E(I)) with τ (J) / ∈ A EX (I). Now consider a profile A with n agents in which n/2 + 1 agents only approve of the projects in τ (J); the other agents being unconstrained. On the JA side, the majoritarian outcome will be J. Since the majoritarian outcome is admissible, any majority-consistent rule F must return {J} on E(I) and A, which does not correspond to an exhaustive budget allocation.
This result is far-reaching because exhaustiveness really clashes with basic properties of JA. 10 To circumvent this problem and to enforce exhaustiveness, we will investigate two approaches: either encoding exhaustiveness in the integrity constraint or designing new JA rules.

Exhaustive Embeddings
We introduce the exhaustive tractable embedding, which is an adaptation of the tractable embedding to maintain exhaustiveness when there is exactly one resource.
Consider a PB instance I = R, b, P, c with R = {r}. Similarly to the previous embeddings, we introduce the ∨-nodes of the integrity constraint as N (j, v, c * ), where j is a project index, v is the budget used in terms of resource r, and c * is the cost of the cheapest non-selected project. They are defined as follows: • If j = m + 1, we have: • If v + c(p j ) ≤ b, let c * = min(c * , c(p j )), then we have: 10 Were it not for our assumption that every project must have at least one supporter (which rules out certain profiles), Proposition 11 could be strengthened to say that no unanimous JA rule is exhaustive (F is unanimous if F (J, . . . , J) = {J} for all judgments J). Participatory Budgeting with Additional Constraints The exhaustive tractable embedding ETE returns the integrity constraint defined by N (1, 0, max p∈P c(p)). We can prove that the embedding ETE behaves as it is expected to.
Proposition 12 The exhaustive tractable embedding is correct and exhaustive, and returns an integrity constraint Γ represented as a DNNF circuit of size O(m 2 × |{c(π) | π ⊆ A(I)}|), for any I = R, b, P, c where |R| = 1.
Proof The structure of the embedding is very similar to that of the tractable embedding TE presented above. We only prove that the embedding is exhaustive. Let I = R, b, P, c be a PB instance. Consider an outcome J ∈ J(ETE(I)) and the budget allocation π such that π = τ (J). Note that the budget allocation π is exhaustive if and only if the cheapest not selected project does not fit in it. Observe that in the exhaustive tractable embedding we are keeping track of the cheapest project that has not been selected so that whenever all the projects have been considered two cases can be are left. If the cheapest project fits in the budget allocation then the latter is not exhaustive and we link the branch to the ⊥ leaf. Otherwise the budget allocation is exhaustive and the leaf can be linked to it. This proves that the embedding is exhaustive. The fact that the constructed integrity constraint is a DNNF circuit of the suitable size is almost immediate given all the proofs we have already seen on that topic.
This embedding is only defined for instances with a single resource and, unfortunately, the idea does not generalise (under some widely accepted computation complexity assumptions). The reason is that, when there are several resources, then there could be exponentially many "cheapest projects".
In the following we turn to another way to enforce exhaustiveness: asymmetric JA rules.

Asymmetric Judgment Aggregation Rules
In the context of PB, when an agent does not include a project in her approval ballot, this does not imply that she does not want to see the project being funded, but rather that it is not one of her top projects. Therefore, to implement PB via JA we need to adapt the familiar JA rules so that not selecting a project (i.e., not accepting a proposition) is not interpreted as a rejection. To this end we introduce the new family of asymmetric JA rules. They avoid the symmetric treatment of acceptance and rejection common in most, if not all, established JA rules.
Definition 6 (Asymmetric Additive Rules) Let F be an additive JA rule associated with f : (2 X ) n × Lit(X) → R ≥0 . Then its asymmetric counterpart Fasy is the rule where for every integrity constraint Γ and every profile J , we have: Here is a small positive constant such that: Importantly, this definition applies only if f is R ≥0 -valued. The use of guarantees that accepting positive literals will always be more appealing than accepting negative ones, while being small enough so as to not impact the relative values of positive literals. Note that = 1 |X|+1 is a suitable choice for the three rules defined near the end of Section 2.2.
The class of asymmetrical additive rules is particularly interesting for us, as we can show that every rule in this class satisfies exhaustiveness.
Proposition 13 Let F be an additive JA rule associated with an R ≥0 -valued function f . Then the asymmetric counterpart of F satisfies exhaustiveness.
Proof Executing Fasy involves computing a score for every admissible candidate outcome J. By definition, no negative literal in J can contribute to its score, while every positive literal makes a strictly positive contribution of at least . Thus, flipping a negative literal always results in an increased score. So Fasy only returns admissible judgments for which flipping any negative literal would violate the integrity constraint. This corresponds to exhaustiveness.
Observe that the asymmetric counterpart of any additive rule is itself additive (and similarly for scoring rules, albeit not for AMRs). Finally, it is interesting to note that the asymmetric variant of the leximax rule is very similar to the well-known greedy approval rule for PB (Aziz and Shah, 2020). 11

Axiomatic Analysis
Axioms are means for encoding formal properties related to the normative adequacy of mechanisms for collective decision making (Thomson, 2001 Table 1 Axiomatic results: "sym" denotes the usual rule and "asym" its asymmetric counterpart. a given PB axiom A, we say that the JA rule F satisfies A with respect to embedding E if, for every PB instance I and profile A, the PB rule mapping I and A to τ (F (E(I), A)) satisfies A.
Moreover, for a resolute rule F , the axioms of Talmon and Faliszewski (2019) are usually stated as "when one moves from an instance/profile pair (I, A) to another pair (I , A ), then if F (I, A) satisfies a certain property, F (I , A ) should satisfy a corresponding property." We generalise these axioms to the irresolute case by requiring that, if every budget allocation returned by our rule for (I, A) satisfies the property in question, then every budget allocation for (I , A ) should satisfy the corresponding property. Note that, still in the context of PB, Baumeister et al. (2020) chose a different generalisation, involving existential rather than universal quantification.
The first axiom we study is called limit monotonicity. It states that after any increase in the budget limit that is not so substantial as to make some previously unaffordable project affordable, any funded project should continue to get funded. This axiom is closely related to that of committee monotonicity for multiwinner voting rules (Elkind et al., 2017).
Definition 7 (Limit monotonicity) A PB rule F is said to be limit-monotonic if, for any two PB instances I = R, b, P, c and I = R, b , P, c with b ≤ b and c(p) ≤ b for all projects p ∈ P, it is the case that F (I, A) ⊆ F (I , A) for all profiles A.
In the following, we show that this axiom is not satisfied by any of the JA rules of interest, even when there is only one resource.
Proposition 14 None of the Kemeny, the Slater, or the leximax rules, or their asymmetric counterparts satisfy limit monotonicity with respect to any correct embedding.
Proof Assume the embedding is correct. Consider two instances I = R, b, P, c and I = R, b , P, c such that |R| = 1. There are three projects p 1 , p 2 , and p 3 , and the budget limits are b = (4) and b = (5). The profile of interest A together with the instances I and I are presented below, I on the left and I on the right.
We claim that on I, the Kemeny, the leximax rules, and their asymmetric counterpart would all return {{p 1 , p 3 }}. However, they would all return {{p 1 , p 2 }} on I . Project p 3 is thus a witness of the violation of limit monotonicity. For the Slater rule and its asymmetric counterpart, consider the situation depicted below with two instances I = R, b, P, c and I = R, b , P, c involving three projects and a single resource, i.e., |R| = 1. The budget limits are b = (4) and b = (6). We denote by A (on the left) and A (on the right) the corresponding profiles, presented below. On I and A, both the Slater rule and its asymmetric counterpart would return {{p 1 , p 2 }}. On the other hand, on I and A, both rules would return {{p 1 , p 2 }, {p 1 , p 3 }, {p 2 , p 3 }}. Since {{p 1 , p 2 }, {p 1 , p 3 }, {p 2 , p 3 }} = ∅, both projects p 1 and p 2 are witnesses of the violation of limit monotonicity.
We move on to discount monotonicity, an axiom stating that, if the cost of a selected project is reduced, then that project should continue to be selected.
Definition 8 (Discount monotonicity) A PB rule F is said to be discount-monotonic if, for any two PB instances I = R, b, P, c and I = R, b, P, c such that for some distinguished project p ∈ P, we have c(p ) ≥ c (p ), and c(p) = c (p) for all p ∈ P \ {p }, it is the case that p ∈ F (I, A) implies p ∈ F (I , A) for all profiles A.
To study how JA rules deal with discount monotonicity, we introduce a new axiom for JA. This axiom is relevant for us, since it is a sufficient condition for discount monotonicity.
We obtain the following formal connection between the two axioms.
Lemma 15 Every constraint-monotonic JA rule is discount-monotonic with respect to any correct embedding.
Proof Let F be a JA rule that is constraint-monotonic. Let E be a correct embedding. Consider the instances I = R, b, P, c and I = R, b, P, c , where a project p ∈ P became cheaper from I to I as in Definition 8. Let A be an arbitrary profile with p ∈ τ (F (E(I), A)). We need to show that p ∈ τ (F (E(I ), A)). Observe that A(I) ⊆ A(I ). Because E is correct, we also have J(E(I)) ⊆ J(E(I )). Moreover, for every π ∈ A(I ) \ A(I), we have p ∈ π as only c (p) changed in I . Hence, for every outcome J ∈ J(E(I )) \ J(E(I)), we have p ∈ τ (J). From constraint-monotonicity, we have that for every profile A, F (E(I ), A) ⊆ F (E(I), A) ∪ J(E(I )) \ J(E(I)). Hence, for every J ∈ F (E(I ), A), we have p ∈ τ (J).
Our axiom turns out to be satisfied by many JA rules.
Proposition 16 Every additive rule is constraint-monotonic.
Proof Consider any additive rule F . Suppose, that F is not constraint-monotonic. Then there exist two integrity constraints Γ and Γ with J(Γ) ⊆ J(Γ ) and a profile J for which there exists a J ∈ F (Γ , J ) \ F (Γ, J ) with J ∈ J(Γ) \ J(Γ ). As J / ∈ F (Γ, J ), there exists some J ∈ J(Γ) with a higher total score than that of J. Moreover, since J(Γ) ⊆ J(Γ ), this same J would outperform J also under Γ . This implies that J / ∈ F (Γ , J ), which is a contradiction, so we are done.
Recall that several well-known JA rules are additive and thus subject to this result.
Corollary 17 The Kemeny, Slater, and leximax rules as well as their asymmetric counterparts are all discount-monotonic with respect to any correct embedding.
The last two axioms we consider deal with situations where projects are split into subprojects (and the dual operation of merging projects). First, splitting monotonicity states that, if a selected project is split into a set of projects approved by the same agents, then some of these new projects should still be selected. The axiom of merging monotonicity expresses a similar condition when merging projects.
Given a PB instance I = R, b, P, c and a profile A, we say that I = R, b, P , c and A are the result of splitting project p ∈ P into P (with P ∩ P = ∅), if the following conditions are satisfied: • The project p is replaced by P in the set of projects: P = (P \ {p}) ∪ P .
• The total cost of P is that of p: for all p ∈ P , it is the case that c (p ) = 0 d and c (P ) = c(p). • The cost of every other project is as in I: c (p ) = c(p ) for all projects p ∈ P \ P . • The project p is replaced by P in the ballots containing it: for every i ∈ N with p / We also say that I and A are the result of merging P into p given I and A .
Definition 10 (Splitting monotonicity) A PB rule F is said to be splittingmonotonic if, for any two PB instances I = R, b, P, c and I = R, b, P , c with corresponding profiles A and A such that I and A are the result of splitting project p into P given I and A, it is the case that if p ∈ F (I , A) then A ∩ P = ∅ for all A ∈ F (I , A).
Definition 11 (Merging monotonicity) A PB rule F is said to be merging-monotonic if, for any two PB instances I = R, b, P, c and I = R, b, P , c with corresponding profiles A and A such that I and A are the result of merging project set P into project p given I and A, it is the case that P ⊆ F (I, A) implies p ∈ F (I , A).
We first show that splitting monotonicity is satisfied by AMRs and their asymmetric counterparts.
Proposition 18 Every AMR as well as the asymmetric counterpart of every AMR are splitting-monotonic with respect to any correct embedding.
Proof Let F be either an AMR or the asymmetric counterpart of an AMR, and let E be a correct and exhaustive embedding. Consider a PB instance I = R, b, P, c and a profile A. Let J be the JA profile corresponding to A. Let I = R, b, P , c and A be the instance and profile resulting from splitting a given project p ∈ τ (F (E(I), J )) into the set of projects P . Let J be the JA profiles corresponding to A .
Consider an outcome J 1 ∈ F (E(I), J ). Note that any outcome J that is admissible before and after the splitting, i.e., any J ∈ J(E(I)) ∩ J(E(I )), cannot include either p or any project from P . Since p ∈ τ (F (E(I), J )), this implies that J 1 has a higher total score than any J ∈ J(E(I)) ∩ J(E(I )).
Consider now an outcome J 1 = (J 1 \ {p }) ∪ {p} for some newly created project p ∈ P . By definition of the new cost function, and since E is a correct embedding, we have J 1 |= E(I ). J 1 thus determines an admissible outcome for the constraint corresponding to I . Based on the definition of J , it is clear that n J = n J for every ∈ aug(J 1 \ {x p }) and that n J x p = n J xp . Hence, because the internal score used by F only depends on the number of supporters, we know that J 1 and J 1 have the same total score. This implies that J 1 has a higher total score than any J ∈ J(E(I)) ∩ J(E(I )). Thus, J(E(I)) ∩ F (E(I ), J ) = ∅. As for every newly admissible judgement J ∈ J(E(I )) \ J(E(I)) we have P ∩ τ (J ) = ∅, every outcome returned by F would have a non-empty intersection with P .
Interestingly, this result provides a sufficient condition for PB rules to satisfy splitting monotonicity: any rule behaving as an AMR (with a suitable definition of AMR for PB) will satisfy it.
For the specific set of rules we study, we obtain the following corollary.
Corollary 19 The Kemeny, Slater, and leximax rules as well as their asymmetric counterparts are all splitting-monotonic with respect to any correct embedding.
Interestingly, when enforcing exhaustiveness through the embedding, this last result is no longer valid for symmetric rules.
Proposition 20 None of the Kemeny, the Slater, or the leximax rules satisfy splitting monotonicity with respect to any correct and exhaustive embedding.
Proof Consider the following pairs of instances and three-agent profiles: I and A on the left and I and A on the right. Both involve just one resource. Cost 2 1 /2 1 /2 1 /2 1 /2 1 1 Observe that I and A are the result of splitting p 2 into {p 1 2 , p 2 2 , p 3 2 , p 4 2 }, given I and A. We leave the relevant computations to the reader, but the Kemeny, the Slater, and the leximax rules would all return {{p 1 , p 2 }} on (I, A) when used with a correct and exhaustive embedding. However, they would return {{p 1 , p 3 , p 4 }} on (I , A ). Hence, p 2 is a witness of a violation of splitting monotonicity.
We finally investigate merging monotonicity. It turns out that none of the rules we are considering in this paper satisfy it. A simple counterexample proving this claim is provided next.
Proposition 21 None of the Kemeny, the Slater, or the leximax rules, or their asymmetric counterparts satisfy merging monotonicity with respect to any correct embedding.
Proof Consider the following pairs of instances and one-agent profiles: I and A on the left and I and A on the right. Both involve just one resource. Observe that I and A are the result of merging {p 3 , p 4 , p 5 , p 6 } into project p 3 , given I and A. It is easy to see that the Kemeny, the Slater, and the leximax rules would all return {{p 3 , p 4 , p 5 , p 6 }} on (I, A) when used with a correct embedding. However, they would return {{p 1 , p 2 }} on (I , A ). Hence, p 3 is a witness of a violation of merging monotonicity. Moreover, since the only agent approves of every projects, the same hold for the asymmetric counterpart of the rules.
To conclude this section, we shortly discuss the overall axiomatic picture for JA rules. The most striking results are that none of our rules satisfy limit and merging monotonicity. For limit monotonicity, it should be noted that no PB rule we know of satisfies it (Talmon and Faliszewski, 2019). It seems to be too strong a requirement. For merging monotonicity, the situation is less clear-cut: Some PB rules satisfy it but none that are widely used. Our other axiomatic results are in line with those of Talmon and Faliszewski (2019).
Overall, relative to the range of axioms we have considered here, we may summarise the situation by saying that JA rules perform similarly to other PB rules in normative terms.

Conclusion
We have proposed an efficient way of determining the outcome for PB problems by means of JA rules. The richness of the JA framework allowed us to develop embeddings for generalised forms of PB. While the resulting problems are computationally hard in general, we nevertheless were able to present useful parameterized embeddings for them. Regarding the axiomatic properties of JA rules for PB, we observed that a naïve way of embedding PB into JA leads to rules that violate the crucial exhaustiveness requirement of PB. We then suggested two ways of enforcing exhaustiveness: either through exhaustive embeddings or by using asymmetric JA rules. We also analysed several common JA rules and their asymmetric counterparts in view of basic monotonicity axioms for PB and found that the asymmetric rules fare better than the original rules.
In terms of future work, it would be interesting to study a wider range of PB axioms, to allow us to better differentiate between different JA rules. Indeed, for now, the Kemeny, Slater, and leximax rule cannot be distinguished based on the PB-specific axioms we studied (although they of course can be distinguished by means of axioms studied in the JA literature). A particularly exciting direction would be to investigate proportionality axioms such as those introduced by Aziz et al. (2018), Haret et al. (2020), and Chingoma et al. (2022). Interestingly, Chingoma et al. (2022) introduced proportionality requirements in the context of JA. However the rules satisfying those requirements are not additive rules and thus do not fit within our framework. It would therefore be interesting to investigate in more depth whether we can find additive rules that satisfy a relevant notion of proportionality. Another important direction would be to establish direct links between certain JA rules and their counterparts for PB. We, for instance, observed that the leximax rule is a refinement of the greedy approval rule-the most widely used PB rule in practice. Drawing similar parallels between other JA and PB rules is a natural next step for the research agenda initiated in this paper.
Beyond its immediate significance to the theory and practice of PB, we believe our work also, more generally, highlights some important aspects of working with different frameworks for collective decision making. The high expressive power of JA permits us to encode many problems of practical interest as well as properties and constraints. Finding efficient ways of solving decision problems embedded into JA can be hard, but once identified, these methods allow for great flexibility.