Chore division on a graph

12/05/2018 ∙ by Sylvain Bouveret, et al. ∙ 0

The paper considers fair allocation of indivisible nondisposable items that generate disutility (chores). We assume that these items are placed in the vertices of a graph and each agent's share has to form a connected subgraph of this graph. Although a similar model has been investigated before for goods, we show that the goods and chores settings are inherently different. In particular, it is impossible to derive the solution of the chores instance from the solution of its naturally associated fair division instance. We consider three common fair division solution concepts, namely proportionality, envy-freeness and equitability, and two individual disutility aggregation functions: additive and maximum based. We show that deciding the existence of a fair allocation is hard even if the underlying graph is a path or a star. We also present some efficiently solvable special cases for these graph topologies.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Fair division of goods and resources is a practical problem in many situations and a popular research topic in Economics, Mathematics and Computer science. Sometimes, however, the objects that people have to deal with are undesirable, or, instead of utility create some cost. Imagine that a cleaning service firm allocates to its teams a set of offices, corridors, etc in a building. Each team has some idea of how much effort each room requires. The cost of the whole assignment for a team may be in the form of time the team will have to spend on the job, and this might depend on whether the work in all assigned rooms can start simultaneously or whether they have to be treated one after another. Moreover, for practical reasons, it is desirable that each team’s assignment is a contiguous set of rooms. As another example consider a firm that supervises the operation of the computer network during a conference. Each of its employees has to choose one of the possible shifts, but shifts scheduled at different times of the conference may incur different opportunity cost for various persons. Moreover, we can assume that everybody prefers to have just one uninterrupted period to spend at work.

The constraints described above could be represented by an undirected graph whose vertices are rooms or time intervals and there is an edge between two vertices if the respective rooms are adjacent; or the corresponding time periods immediately follow each other. Each agent should obtain a connected piece of the underlying neighborhood graph. Complete graphs correspond to the ’classical’ case with no connectivity constraints. By contrast, paths and stars represent the simplest combinatorial structures, and yet such graphs can be used to model a rich variety of situations. For example, a path may represents successive time intervals and a star corresponds to a building with a central foyer and mutually non-connected rooms accessible from this foyer.

Related work

The mathematical theory of fair division started with the seminal paper of Steinhaus (1948). Although originally most researchers focused on divisible items (the topic is also known as the cake-cutting problem), fair division of indivisible goods has also received a considerable amount of attention in the traditional and computational social choice literature. The interested reader can for instance read the survey by Bouveret et al. (2015) for an overview of this topic.

Several recent papers combine graphs and fair division of indivisible items by assuming that agents are located in the vertices of a graph. For instance, Chevaleyre et al. (2007) and Gourvès et al. (2017) consider the case where each agent has an initial endowment of goods and can trade with her neighbors in the graph. The authors study outcomes that can be achieved by a sequence of mutually beneficial deals.

In the paper by Bouveret et al. (2017) for the first time a graph-based constraint on agents’ bundles has been imposed. The authors model the items as vertices of a graph and they require that each agent should receive a bundle that forms a connected subgraph. They show that even if the underlying graph is a path the problems to decide whether there exist proportional or envy-free divisions with connected shares are NP-complete. In case of stars, envy-freeness is also intractable, but a proportional division can be found by a polynomial algorithm. In addition, Bouveret et al. (2017) study maximin (MMS) allocations, a fairness notion introduced by Budish (2011). They show that a MMS allocation always exists if the underlying graph is a tree, provide a polynomial algorithm to find one in this case and show that a cycle may admit no MMS allocation.

This work inspired other authors who also considered allocations on a graph with the additional constraint that each bundle has to be connected. Suksompong (2017) considers only paths and studies approximately fair (proportional, envy-free and equitable) allocations up to an additive approximation factor. He shows that for all the three fairness notions there is a simple approximation guarantee derived from the maximum value of an item and that for proportionality, as well as equitability, an allocation achieving this bound can be computed efficiently.

Biló et al. (2018) deal with two relaxations of envy-freeness: envy-free up to one good, briefly EF1 (an agent does not think that another agent’s bundle, possibly with one of its outer items removed, is more valuable than her own bundle) and envy-free up to two outer goods, briefly EF2. They characterize graphs admitting allocations fulfilling these notions and provide efficient algorithms to find such allocations.

Lonc and Truszczynski (2018) study MMS allocations of goods. For the underlying graph being a cycle they identify several cases when MMS-allocations always exist (e.g. at most three agents and at most 8 goods, the number of goods not exceeding twice the number of agents, fixed number of agent types) and provide results on allocations guaranteeing each agent a certain portion of her maximin share.

Igarashi and Peters (2018) study Pareto-optimality. They show that for paths and stars a Pareto optimal allocation can be found efficiently, but the problem is NP-hard even for trees of bounded pathwidth. They also show that it is NP-hard to find a Pareto-optimal allocation that satisfies maximin share even on a path.

It is worth noting that although the study of connected fair division is relatively recent in the context of indivisible items, there is an important literature on the contiguity requirement in the context of cake-cutting. From the great number of various results we consider among the most interesting ones the contrast between the proven existence of envy-free (Stromquist, 1980) and equitable (Aumann and Dombb, 2010; Cechlárová et al., 2013) divisions with connected pieces and, on the other hand, the nonexistence of finite algorithms for computing them (Stromquist, 1980; Cechlárová and Pillárová, 2012).

Beyond considering the connectivity constraint, an important aspect in which our work departs from the mainstream literature on fair division is the fact that we consider negative items (chores).

Chore division of divisible goods was mentioned for the first time by Gardner (1978). Although straightforward modifications of some algorithms for positive utilities can also be applied to the chore division context (e.g., the Moving Knife algorithm for proportional divisions), it happens more often that chore division problems are more involved than their fair division counterparts. For example, the discrete algorithm for obtaining an envy-free division of divisible chores for three persons by Oskui (Robertson and Webb, 1998, pages 73-75) needs nine cuts and the procedure based on using four moving knifes makes 8 cuts (Peterson and Su, 2002), while in the Selfridge’s algorithm for envy-free (positive) division (Woodall, 1980) five cuts suffice. If the number of agents is 4, the moving-knife procedure by Brams et al. (1997) needs 11 cuts, while the first algorithm for envy-free division of chores, given by Peterson and Su (2002), needs 16 cuts.

The fact that chore division has been given much less attention in research is mirrored also in monographs on fair division. For example, Robertson and Webb (1998) only deal with chores in Section 5.5; of Chapter 7 on cake cutting in the book Economics and Computation edited by Rothe (2015) only Section 7.4.6 treats chores and Chapter 12 on fair division of indivisible goods in the Handbook of Computational Social Choice by Bouveret et al. (2015) does not mention chores at all.

Of the more recent works on chore division let us mention Caragiannis et al. (2012) who deal with divisible and indivisible goods and chores from the point of view of the price of fairness for three fairness notions. Heydrich and van Stee (2015) consider the price of fairness for the fair division of infinitely divisible chores. Aziz et al. (2017) also deal with chores; the considered fairness notion is maximin share guarantee. In the divisible chores setting, Dehghani et al. (2018) give the first discrete and bounded protocol for envy-free chore division problem and Farhadi and Hajiaghayi (2018) prove the lower bound for the number of queries in a proportional protocol for chores.

Finally, in the context of indivisible items, where the existence of fair allocations cannot be ensured, it is rather natural to study approximations of the fairness criteria. Markakis and Psomas (2011) prove a worst case guarantee on the value that every agent can have and they propose a polynomial algorithm for computing allocations that achieve this guarantee. By contrast, they show that if there is no polynomial algorithm to decide whether there exists an allocation where each agent can get a bundle worth at least for any constant . Lipton et al. (2004) focus on the concept of envy-freeness. They show that there exists an allocation with maximum envy not exceeding the maximum marginal utility of a good. However, the problem of computing allocations with minimum possible envy is hard, even in the case of additive utilities.

Our contribution

In this paper, we extend the work of Bouveret et al. (2017) about fair division of goods on a graph. We also use the connectivity constraints defined by a graph on the items. However, we deal with nondisposable undesirable items, often called chores. We use three classical fairness criteria, namely proportionality, envy-freeness and equitability, and two different individual disutility aggregation functions: additive and maximum based. We show that dealing with goods and chores is inherently different, in particular, it is impossible to transform a chore instance simply by negating the utility values and applying the algorithm that works for goods.

Then we investigate the complexity of the problems to find a fair allocation of chores. It is known that these problems are hard on complete graphs in the additive case, but the maximum-based case, as far as we know, has not been studied before. Therefore, we complement the picture by providing efficient algorithms for proportionality and equitability, and show that envy-freeness leads to an NP-complete problem. Further, we concentrate on two special classes of graphs: paths and stars.

In more detail, we provide a general reduction for paths that directly implies NP-completeness of the existence problems for all the considered fairness criteria and both disutility aggregations. Moreover, by a very small modification of the reduction we obtain that these problems are hard even in the binary case i.e., when disutility values for chores are either 0 or 1.

By contrast, if the underlying graph is a star, we propose an efficient algorithm, based on bipartite matching techniques, to decide whether a valid allocation exists such that each agent has disutility 0. This in turn implies that envy-freeness and equitability criterion admit efficient algorithms for decision problems in the binary case. Matching techniques lead to efficient algorithms also in the maximum-based case, even when disutilities are not restricted to be binary. In the additive case we provide an efficient algorithm for proportionality. On the other hand, it is NP-complete to decide the existence of envy-free or equitable valid allocations on a star.

This paper is organized as follows. In Section 2 we introduce the model of connected fair division of indivisible chores and the definitions of the various fairness criteria we use in the paper. Our technical results are presented in Sections 3, 4 and 5 which respectively deal with the cases where the underlying graph is a complete graph, a path and a star. Table 1 shows an overview of the results introduced in this paper. Finally, we discuss the results and some open problems in Section 6.

complete graph path star
additive maximum additive maximum additive maximum
proportionality NPC P NPC NPC P P
envy-freeness NPC NPC NPC NPC NPC NPC
equitability NPC P NPC NPC NPC P
Even with binary disutilities
Polynomial with strict disutilities
Table 1: Overview of the complexities of the existence problems

2 Model

is the set of agents, is an undirected graph. Vertices represent objects, and they are interpreted as nondisposable chores. Each agent has a non-negative disutility (cost, regret) function . The -tuple of disutility functions is denoted by . Let denote the number of vertices of (chores).

An instance of Connected Chore Division CCD is a triple . When we shall occasionally talk about problems with positively interpreted utility, we shall call them Connected Fair Division problems, briefly CFD.

Any subset is called a bundle. We consider two disutility aggregation functions. In the additive case the disutility agent derives from bundle is equal to the sum of the disutilities of the objects that form the bundle, i.e. . In the maximum-based case the disutility of a bundle is derived from the maximum disutility of an object in the bundle, i.e. . If the aggregation function is not specified or if it is clear from the context, the superscript may be omitted. In the maximum-based extension we shall also consider an important binary case when the disutilities of agents for objects are either 1 or 0. The binary case represents the situation of agents finding some objects negative without expressing the “degree of negativity” and some other objects bring them neither nuisance nor joy.

We assume that the disutilities are normalized. This means that and for each agent in the additive and in the maximum-based case, respectively.

An allocation is a function assigning each agent a bundle of objects. An allocation is valid if:

  • for each agent , bundle is connected in ;

  • is complete, i.e., and;

  • no item is allocated twice, so that for each pair of distinct agents .

We say that a valid chore allocation is:

  • proportional if for all ;

  • envy-free if for all ;

  • equitable if for all .

Let us remind the reader that the corresponding notions of proportionality and envy-freeness for CFD are defined by reversing the respective inequalities. Equitability is defined in the same way in both cases, but since no results for goods with connected bundles have been published yet, we shall try to close this gap.

Notice that with maximum-based disutility aggregation, proportionality does not have a similar interpretation as in the additive case, where dividing the disutility by the number of agents corresponds to sharing the total burden. Still, we shall use this term also in the case when agents care for the worst item in their bundle, meaning that we seek an allocation that restricts the disutility by the same threshold for everybody.

Taking into account the large number of existing results concerning the fair division of goods, one could be tempted to try and adapt these results to the case of chores. First, observe that if in a fair division instance there are more agents than items, no proportional and envy-free allocation can exist, which is not necessarily the case with chores. Further, although it seems natural to transform a chore division instance to a ‘dual’ fair division instance simply by replacing each disutility by a ‘reverse’ desirable utility for each agent and each object ( is a sufficiently large real number), we show that the properties of the related instances do not translate.

Example 2.1.

Let us consider the CCD instance with three agents 1,2,3 and four vertices arranged on a path in this order and disutilities given in the left half of Table 2. Its right half shows the utilities for the ‘dual‘ CFD instance obtained for .111For typographical reasons, the disutilities of agents in this and the following example are not normalized to 1, but to 10 in the CCD instances (tables in the left) and to 30 in the corresponding dual CFG instances (tables in the right).

agent 1 6 4 0 0
agent 2 7 0 1 2
agent 3 5 0 0 5
agent 1 4 6 10
agent 2 9 8
agent 3 5 10 5
Table 2: The CCD (left) and CFD (right) instances for proportionality notion

A proportional chore allocation should give each agent a bundle of disutility at most 10/3. does not admit a valid proportional allocation, as nobody is willing to take vertex . In the dual CFD instance a proportional valid allocation exists, simply give agent 1 vertex , agent 2 bundle and agent 3 vertex . This allocation is depicted with stars in the right half of Table 2.

Example 2.2.

Now slightly change the disutilities of agent 3; the new CCD instance and its dual CFD instance are given in Table 3.

agent 1 6 4
agent 2 7 1 2
agent 3 5 5 0
agent 1 4 6 10 10
agent 2 3 10 9 8
agent 3 10 5 5 10
Table 3: The CCD (left) and CFD (right) instances for envy-freeness.

Now has an envy-free valid allocation, namely , and , again depicted with stars in the left half of Table 3. However, there is no envy-free valid allocation in the dual fair division instance . To see this, let us first realize that as there are three agents and four items, exactly one of the agents has to receive a bundle consisting of two vertices. Since each allocated bundle has to be connected, there are exactly three such two-elements bundles: , and . One can see that each such bundle has utility strictly greater than 10 for at least two agents, and as each agent values individual vertices at not more than 10, there will always be somebody envying the agent receiving the two-element bundle.

We see that similarly as in the ’classical’ case of indivisible goods without connectivity constraints, the existence of allocations fulfilling the above definitions is not ensured in general. Therefore we shall deal also with approximate fairness. We can ask whether for a given , a valid chore allocation exists such that each agent receives a bundle such that , or such that or holds for each pair of agents . Later in this paper we shall see that even for paths the problems to decide whether a valid allocation exists such that the disutility of each agent equals 0 is NP-hard. This immediately implies intractability of the just formulated problems for any .

We will consider the following computational problems that all take an instance of CCD as their input. Prop-CCD, EF-CCD and EQ-CCD ask whether admits a proportional, envy-free and equitable allocation, respectively. If we want to stress which disutility aggregation functions is used, we insert prefix Add or Max to this notation.

It is easy to see that all the considered problems belong to the class NP, as given an allocation, it can be verified in polynomial time whether it is valid and also whether it is proportional, equitable (linear in the problem size) or envy-free (in time )).

3 Complete graphs

Note that the classical case (without connectivity requirements) corresponds in our model to the underlying graph being complete. Then, all the problems studied are hard for the additive disutility aggregation. The intractability can be proved using a reduction from Partition (see e.g. Demko and Hill, 1998).

Proposition 3.1.

Add-Prop-CCD, Add-EF-CCD and Add-EQ-CCD are NP-complete even for two agents with the same disutility function and even if the underlying graph is bipartite.

Now suppose that agents aggregate their disutilities using maximum and consider the following algorithm that we shall call greedy: assign each item to agent such that . It is easy to see that the greedy algorithm produces a valid allocation that minimizes .

If we want to decide the existence of an equitable allocation, for each possible disutility target we do the following. We create the bipartite graph with the two parts of the vertex set corresponding to the set of agents and to the set of chores, respectively, and with the edge set defined by if . Then we check whether admits a matching that covers . If the answer is no, there is no valid allocation such that for each agent. If the answer is yes, we try to assign the remaining chores greedily. We conclude that there exists an equitable allocation with the common disutility equal to if and only if the greedy algorithm does not assigns to any agent a chore for which she has a disutility exceeding . This can be summarized as follows.

Theorem 3.2.

MAX-PROP-CCD and MAX-EQ-CCD can be solved in polynomial time.

By contrast, envy-freeness criterion leads to an intractable problem. In the following proof we provide a reduction from the NP-complete problem (2,2)-e3-sat (Berman et al., 2003) that asks, given a Boolean formula in Conjunctive Normal Form, where each clause in has size three, and each variable occurs exactly twice unnegated and exactly twice negated, whether is satisfiable.

Theorem 3.3.

MAX-EF-CCD is NP-complete even if the underlying graph is complete.

Proof.

Let formula be given with a set of variables and set of clauses . Let be the set of literals i.e., and for any , let denote the clause containing literal . Let denote the set of literals in clause .

For each formula we construct an instance of MAX-EF-CCD as follows. The set of chores is , where with are literal chores, are clause chores,  are dummy clause chores and , with

are dummy variable chores. The chore corresponding to literal

will be denoted .

We further assume that the set of chores is ordered while the ordering within each subset is the same as the order in which the chores in the respective subset have been written above. The position of a chore in this ordering is equal to the disutility derived by each agent from chore , unless defined differently.

The set of agents is , where are clause agents, are dummy clause agents, are variable agents and with are dummy variable agents.

The disutilities are defined in Table 4, where for each agent we list the chores with disutilities equal to 0 and to , where is fixed. The disutility of any chore to agent who does not have displayed in this table is equal to .

agent disutility equal 0 disutility equal
Table 4: Disutilities in the proof of Theorem 3.3.

Let us briefly explain how the reduction works before proving that it is correct. Each variable agent will receive a subset of literal chores that correspond to her variable. Each dummy variable agent will receive her corresponding dummy variable chore and will envy the corresponding variable agent as soon as she does not receive a subset of literal chores containing either two positive literals or two negative literals. Each clause agent will receive a clause chore as well as at least one literal chore associated with one of her literals. Clause chores ensure that no variable agent will envy a clause agent. Furthermore, each dummy clause agent will receive her corresponding dummy clause chore and will envy her corresponding clause agent as soon as she does not receive at least one of her corresponding literal chores.

Assume first that is a truth assignment that satisfies all clauses in . We construct from an assignment as follows. For each variable , if is false according to then , otherwise . Furthermore,  and  is true in . Finally, for and for and . Clearly, is valid. It is easy to check that this allocation is envy free. Namely, the disutility agents of receive in is 0, so they do not envy. Take a dummy agent . This agent does not envy because and for each agent the bundle contains a chore such that is a strictly positive integer.

Conversely, suppose that there is a valid assignment such that no agent envies another one. In the first part of the proof we use mathematical induction on the reverse ordering of the chores in the following way: we take the next chore and argue that must belong to the bundle of a certain agent . Let us say that agent was treated treated.

As the disutility of is maximum of all chores, if for any agent then will envy any other agent. Therefore . Now suppose that for each such that . Take such that . If for some agent then will envy any other agent that was not treated yet.

Similarly, by induction for we show that As the disutility of is maximum of all chores that have not yet been assigned, if for some agent then will envy any other agent in . Therefore Now suppose that for each . Take . If for any agent then will envy any agent not treated so far.

By an analogical inductive argument we show that or for each because otherwise the agent that gets this chore will envy any untreated agent (for example, an agent in ).

Now we know that the disutility of each agent in is at least and does not envy agent . So we must have that either or for each . Let us say that is false in the former case and that is true in the latter case. Finaly, so as no agent envies , we get that must contain at least one chore for , and due to the truth values and assignment of chores in defined above, this chore must correspond to a true literal in clause . Hence we obtain an assignment of truth values that makes true. ∎

4 Paths

Even if the underlying graph is restricted to be a path then all the considered chore division problems are intractable, as we now show. All the proofs in this section are based on the same construction starting from an instance of (2,2)-e3-sat.

So let a formula as an instance of (2,2)-e3-sat be given with variables and clauses . By we denote the set of literals in , i.e. and for denotes the clause that contains literal . Notice that the structure of the formula implies and hence .

Let be given. We construct an instance of CCD with the set of chores where are clause chores, are literal chores and are variable chores. The number of chores is thus . The graph defining the neighborhood relation between chores (illustrated in Figure 1) has the edges

  • for ;

  • ;

  • for ;

  • for .

Figure 1: The graph for Lemma 4.1

The set of agents in is , where are literal agents, , are variable agents and are dummy agents (observe that for any ). So the total number of agents in is .

Let us remark that each literal from formula has in its ‘corresponding’ chore in and agent in ; they will be denoted by and , respectively.

For each agent her disutility is 0 for some specific chores and the total disutility of 1 for agent is distributed uniformly among the remaining chores, to achieve normalization. In more details:

If is a literal agent then:

If then:

If then:

and for each agent we have for each .

Lemma 4.1.

If formula is satisfiable then admits a valid allocation such that for each agent . If is not satisfiable then for any valid allocation there exists an agent whose bundle has disutility greater than .

Proof.

Assume first that is a truth assignment of that satisfies all clauses in . We construct from a valid assignment of chores in as follows. Assign each to . For each variable assign agent the bundle and the agents objects and , respectively if is true and assign agent the bundle and the agents chores and , respectively if is false. Finally, choose the first true literal in each clause and assign the corresponding literal agent chore . Each agent in is assigned an empty bundle. It is easy to see that each agent receives a bundle whose disutility is 0, everybody receives a connected piece (if any) and that all chores are assigned.

Conversely, suppose that there is a valid assignment of chores in such that everybody receives a bundle with disutility at most . As any nonzero disutility is at least this implies that each agent’s bundle is either empty of has disutility 0. We now construct a truth assignment for as follows. Note first that chore must be assigned to agent . Further, for each , chore must be assigned to some agent that corresponds to a literal contained in clause . Now suppose that for some , agents as well as , for are assigned some clause chores. This means that chores as well as must both be assigned to agent , but as chore is assigned to agent in any such assignment, agent gets a disconnected piece, which is a contradiction. Hence, set variable to be true if bundle is assigned to agent in and set to be false if bundle is assigned to agent . It is easy to see that this definition of truth values is consistent and makes formula true. ∎

Now we use Lemma 4.1 in the following results.

Theorem 4.2.

Let be arbitrary. If then there is no polynomial algorithm to decide if an instance of CCD admits a valid allocation such that for each , even if is a path. Hence, Add-Prop-CCD is NP-complete.

Proof.

As the number of agents in is , the disutility of each agent in a -proportional allocation should be at most . However, each chore with a positive disutility brings each agent at least , so the result is directly implied by Lemma 4.1. ∎

As in , at least one agent gets nothing. Hence in any envy-free or equitable allocation everybody has to get a bundle with disutility 0. So Lemma 4.1 directly implies also the following assertions.

Theorem 4.3.

Add-EF-CCD and Add-EQ-CCD are NP-complete if is a path.

For the maximum-based disutility extension, let us change the construction in the beginning of this section slightly. Namely, each positive disutility of an item will be set to 1. The same arguments as above are still valid, so we get the following assertion.

Theorem 4.4.

Max-EF-CCD and Max-EQ-CCD are NP-complete if is a path, even in the binary case.

5 Stars

Let denote the center of the star. As each agent has to get a connected bundle, only the agent that is assigned can get more than one chore. According to the fairness criterion used, there are necessary conditions that each agent has to fulfill, so as to be entitled to be assigned ; we shall call such an agent central. If there is no agent who fulfills these conditions then there is no valid allocation with the desired properties. If there exists such an agent, we still have to decide about the assignment of the leaves to the other agents. For this graph topology we first present efficient algorithms and then proceed to hard cases.

5.1 Easy cases

All the easy cases use a similar idea, borrowed from Bouveret et al. (2017). First we guess a central agent . This agent gets as many leaves as possible, and the assignment of the other leaves to other agents is found by employing an efficient matching algorithm in bipartite graphs.

We can also perform a similar complexity analysis for all the algorithms. The upper-bound on the number of steps depends on the matching algorithm used. The bipartite graph constructed in the algorithm has vertices and edges. The Hopcroft-Karp matching algorithm applied to a graph with vertices and edges runs in steps, which in our case thus means steps. Moreover, we might need to repeat the procedure for each agent, and that leads an overall complexity of .

Theorem 5.1.

Add-Prop-CCD is solvable in polynomial time if is a star.

Proof.

First, a central agent must fulfill . Let us check for each such agent whether there is a proportional valid allocation assigning to .

To this end, we create a bipartite graph with , and if and only if ; the weight of this edge is .

We find a maximum weight matching in . A proportional valid allocation exists if and only if the weight of is at least . If this is the case, assign the objects to agents in according to and all the unmatched leaves plus the central vertex to . ∎

Now let us deal with a possibility that each agent gets a bundle with disutility 0.

Proposition 5.2.

If is a star then the problem to decide the existence of a valid allocation where each agent gets a bundle with disutility 0 can be solved in polynomial time.

Proof.

To be able to decide the existence of such an allocation, let us first realize that an agent can be central only if . For such an agent let . Now create the bipartite graph where , and if . Clearly, a desired allocation exists if and only if admits a matching that covers all vertices in . ∎

Theorem 5.3.

Max-EQ-CCD is solvable in polynomial time if is a star.

Proof.

Proposition 5.2 helps in deciding the existence of a valid allocation such that everybody gets disutility 0. Now let us deal with the case when all agents receive bundles with positive disutility equal to .

An agent can be a central agent in an equitable allocation with the common disutility equal to only if . Now we proceed differently when this inequality is fulfilled as equation and when it is strict.

If we create a flow network as follows. Its vertices are the source , sink and one vertex for each agent and one vertex for each leaf of . The source is connected to each agent vertex; capacities of arcs for are 1, capacity of arc is . There is an arc of capacity 1 between the vertex corresponding to agent and the vertex corresponding to leaf if and between and leaf if . Each leaf vertex is connected to , the capacities of these arcs are also 1. A desired allocation exists if and only if there is a flow of size in this network, namely, the leaves are allocated to agents according to the agent-leaf arcs with nonzero flow.

If we have moreover to ensure that agent gets at least one leaf such that . The above construction of the flow network will be modified in the following way. Agent will not be connected with leaves directly, but there will be two more vertices and the following arcs: with capacity and arcs for each leaf such that ; arc with capacity and arcs for each leaf such that . The construction of the flow network is shown in Figure 2. Again, a desired allocation in which agent gets at least one leaf with disutility exactly exists if and only if there is a flow of size in this network.

if

if
Figure 2: All the thin arcs have capacity equal 1. Capacity of thick arcs is shown next to them. The condition for dotted arcs to be included is shown next to them.

As we shall see later, the problem of deciding the existence of an envy-free valid allocation in the additive case is in general NP-complete. However, there is a plausible efficiently solvable special case. We say that agents’ preferences are strict on chores if for any agent and any pair of distinct vertices .

Theorem 5.4.

Add-EF-CCD is solvable in polynomial time if is a star and the agents’ preferences are strict on chores.

Proof.

If then each agent has to get a bundle with disutility 0, and since preferences are strict, this is only possible if each agent gets at most one vertex, namely the one where she has disutility 0. We can easily verify whether this happens by matching techniques.

Now let us proceed to the case when agents receive bundles positive disutility. Let us in turn check for each agent whether she can be the central agent. To this end, order all the vertices in according to ’s disutility increasingly (we might possibly rename the the vertices in )

(1)

and notice that the central agent will receive exactly vertices. The necessary conditions a central agent must therefore fulfill are:

  • vertex must be among the vertices and

These conditions imply that when assigned the bundle , agent will not envy any other agent. We still have to ensure no envy among other agents.

Let us construct the bipartite graph with , and if the following inequality is fulfilled:

(2)

Finally, there exists in an envy-free assignment if and only if admits a perfect matching . Namely, agent is assigned bundle and the other agents chores according to . ∎

The proof of the previous theorem can easily be adapted also for the maximum based disutility aggregation.

Theorem 5.5.

Max-EF-CCD is solvable in polynomial time if is a star and the preferences of agents are strict on chores.

Proof.

When checking whether agent cen be central, after we permute the vertices of according to ’s disutility increasingly, it is easy to see that it suffices to check just condition . Further, in the construction of the bipartite graph condition (2) should be replaced by

(3)

and the rest of the proof follows. ∎

5.2 Hard cases

It turns out that the only intractable problems when the underlying graph is the star are connected with envy-freeness and equitability when the disutilities are aggregated additively.

Theorem 5.6.

Add-EF-CCD is NP-complete even if the underlying graph is a star.

Proof.

The reduction is from (2,2)-e3-sat. A boolean formula has the set of variables and the set of clauses . By we denote the set of literals, i.e. and for denote the clause that contains literal . Let denote the subset of literals appearing in clause .

We construct an instance of Add-EF-CCD with chores and agents defined as follows. The set of chores is , where denotes the center of the star , are variable chores and are literal chores. Observe that each literal has its corresponding chore which will be denoted by .

The set of agents is , where are clause agents and , are variable agents.

The utility functions are defined as follows.

If is a clause agent then:

If then:

where is such that .

If then:

If then:

If then:

Assume first that is a truth assignment that satisfies all clauses in . We construct from a valid assignment of chores as follows. For each variable , if is true, assign and to and respectively, and if is false, assign and to and . Furthermore, for each clause pick literal which is true and assign to . Finally, assign to , and the remaining chores to . It is easy to check that this allocation is envy-free.

Conversely, suppose that there is a valid assignment of chores such that no agent envies another one. Only the central agent can receive strictly more than one chore, and, as a consequence, this central agent must receive at least chores (otherwise some chores will be left unassigned). Suppose that the central agent is not . Then this agent will receive at least two chores with the highest disutility, and hence will envy any other agent receiving just one chore. Therefore, only can be the central agent.

Suppose that receives a non-zero disutility. Then she will envy any other agent receiving either one chore other than or one or no chore at all. It thus means that and each chore must be assigned to some other agents.

Since provides a non-zero disutility to every agent, no agent can receive an empty bundle; otherwise each agent that receives chore will be envious.

If is not assigned to then will envy the agent who receives it. Hence, is assigned to in . This in turn implies that each agent should receive chore for some . This also implies that each variable agent should receive a chore for which she has disutility 0 or , which means that chore is either assigned to agent or .

We now construct truth assignment as follows. If is assigned to in then set to be true, and otherwise (i.e. is assigned to ) set to be false. We will show that satisfies each clause . Let be the literal of such that is assigned to . Assume that is a positive literal of variable (the negative case can be treated in a similar way). If is assigned to agent then she will envy agent , leading to a contradiction. Therefore, is assigned to agent , is set to true and clause is true. ∎

The equitability criterion also leads to an NP-complete problem.

Theorem 5.7.

Add-EQ-CCD is NP-complete if is a star.

Proof.

We shall provide a polynomial reduction from the following version of the NP-complete problem partition (Garey and Johnson, 1979); symbol denotes the set .

Instance : The set of integers such that .
Question: Does there exist a partition of such that ?

Let us construct an instance of Add-EQ-CCD as follows. The set of chores is , where . Chore is the center of the star, the other chores are its leaves. The set of agents is , where . The disutilities of agents are as follows and it can be easily checked that they are all normalized.