Fair allocation of combinations of indivisible goods and chores

07/27/2018 ∙ by Haris Aziz, et al. ∙ KYUSHU UNIVERSITY UNSW 0

We consider the problem of fairly dividing a set of items. Much of the fair division literature assumes that the items are "goods" i.e., they yield positive utility for the agents. There is also some work where the items are "chores" that yield negative utility for the agents. In this work, we consider more general scenarios where for any item, an agent may have negative or positive utility for it. We show that whereas some of the positive axiomatic and computational results extend to this more general setting, others do not. We also point out several gaps in the literature regarding the existence of allocations satisfying certain fairness and efficiency properties as well as the computational complexity of computing such allocations.

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

Consider a group of students who are assigned to a certain set of coursework tasks. Students may have subjective views regarding how enjoyable each task is. For some people, solving a mathematical problem may be fulfilling and rewarding. For others, it may be nothing but torture. A student who gets more cumbersome chores may be compensated by giving her some valued goods so that she does not feel hard done by.

This example can be viewed as an instance of a classic fair division problem. The agents have different preferences over the items and we want to allocate the items to agents as fair as possible. The twist we consider is that whether an agent has positive or negative utility for an item is subjective. Our setting is general enough to encapsulate two well-studied settings: (1) “good allocation” in which agents have positive utilities for the items and (2) “chore allocation” in which agents have negative utilities for the items. The setting we consider also covers a third setting (3) “allocation of objective goods and chores” in which the items can be partitioned into chores (that yield negative utility for all agents) and goods (that yield positive utility for all agents). Setting (3) covers several scenarios where an agent could be compensated by some goods for doing some chores.

Our contribution We suggest a very simple yet general model of allocation of indivisible items that properly includes chore and good allocation. For this model, we present some case studies that highlight that whereas some existence and computational results can be extended to our general model, in other cases the combination of good and chore allocation poses interesting challenges not faced in subsettings. Our central technical contributions are several new efficient algorithms for finding fair allocations.

We first formalize fairness concepts for the general setting. Some fairness concepts directly extend from the settings of good allocation to our setting. Other fairness concepts such as “envy-freeness up to one item” (EF1) and “proportionality up to one item” (PROP1) need to be generalized appropriately.

We show that the round robin sequential allocation algorithm that returns an EF1 allocation for the case of goods does not work in general. We then show a careful generalization of the decentralized round robin algorithm that finds an EF1 allocation when utilities are additive. We also present a different polynomial-time algorithm that always returns an EF1 allocation even when the agents’ utility functions are not additive but monotonic. Turning our attention to Pareto-optimal (PO) and fair allocation, we show that for the case of two agents, there exists a polynomial-time algorithm that finds an EF1 and PO allocation for our setting. The algorithm can be viewed as an interesting generalization of the Adjusted Winner rule  (Brams and Taylor, 1996a, b) that is designed for divisible goods. Finally, if we weaken EF1 to the notion of PROP1, then we show that there exists an allocation that is not only PROP1 but is also contiguous (assuming that items are placed in a line). Such an allocation can be computed in polynomial time.

Related Work Fair allocation of indivisible items is a central problem in several fields including computer science and economics (Aziz et al., 2015; Brams and Taylor, 1996a; Bouveret et al., 2016; Lipton et al., 2004). Fair allocation has been extensively studied for allocation of divisible goods, commonly known as cake cutting (Brams and Taylor, 1996a).

There are several established notions of fairness including envy-freeness and proportionality. The recently introduced maximin share (MMS) notion is weaker than envy-freeness and proportionality (Bouveret and Lemaître, 2016; Budish, 2011) and has been heavily studied in the computer science literature. Procaccia and Wang (2014) showed that an MMS allocation of goods may not always exist; one the positive side, there exists a polynomial-time algorithm that returns a 2/3-approximate MMS allocation (Procaccia and Wang, 2014; Amanatidis et al., 2015). Subsequent papers have presented simpler (Barman and Murthy, 2017) or even better (Ghodsi et al., 2018) approximation algorithms for MMS allocations. Subsequent papers have presented better approximation algorithms with respect to MMS (Barman and Murthy, 2017). In general, checking whether there exists an envy-free and Pareto-optimal allocation for goods is -complete (de Keijzer et al., 2009).

The idea of envy-freeness up to one good (EF1) was implicit in the paper by Lipton et al. (2004). Today, it has become a well-studied fairness concept in its own right (Budish, 2011). Caragiannis et al. (2016) further popularized it, showing that a natural modification of the Nash welfare maximizing rule satisfies EF1 and PO for the case of goods. Barman et al. (2018) recently presented a pseudo-polynomial-time algorithm for computing an allocation that is PO and EF1 for goods. A stronger fairness concept, envy freeness up to the least valued good (EFX), was introduced by Caragiannis et al. (2016).

Aziz (2016) noted that the work on multi-agent chore allocation is less developed than that of goods and that results from one to the other may not necessarily carry over. Aziz et al. (2017) considered fair allocation of indivisible chores and showed that there exists a simple polynomial-time algorithm that returns a 2-approximate MMS allocation for chores. Barman and Murthy (2017) presented a better approximation algorithm. Caragiannis et al. (2012) studied the efficiency loss in order to achieve several fair allocations in the context of both good and chore divisions. Allocation of a mixture of goods and chores has received recent attention in the context for divisible items (Bogomolnaia et al., 2016, 2017). Here, we focus on indivisible items.

2 Our Model and Fairness Concepts

We now define a fair division problem of indivisible items where agents may have both positive and negative utilities. For a natural number , we write . An instance is a triple where

  • is a set of agents,

  • is a set of indivisible items, and

  • is an -tuple of utility functions .

We note that under this model, an item can be a good for one agent (i.e., ) but a chore for another agent (i.e., ). For , we write ; we assume that the utilities in this paper are additive unless specified otherwise. Each subset is referred to as a bundle of items. An allocation is a function assigning each agent a different bundle of items, i.e., for every pair of distinct agents , ; it is said to be complete if .

We first observe that the definitions of standard fairness concepts can be naturally extended to this general model. The most classical fairness principle is envy-freeness, requiring that agents do not envy each other. Specifically, given an allocation , we say that envies if . An allocation is envy-free (EF) if no agent envies the other agents. Another appealing notion of fairness is proportionality which guarantees each agent an fraction of her utility for the whole items. Formally, an allocation is proportional (PROP) if each agent receives a bundle of value at least her proportional fair share . The following implication, which is well-known for the case of goods, holds in our setting as well.

Proposition 1

An envy-free complete allocation satisfies proportionality.

Proof

Suppose that an allocation is an envy-free allocation. Then for each , . Thus, by summing up all the inequalities, . Hence each receives a bundle of value at least , so satisfies proportionality.

A simple example of one good with two players already suggests the impossibility in achieving envy-freeness and proportionality. The recent literature on indivisible allocation has, thereby, focused on approximation of these fairness concepts. A prominent relaxation of envy-freeness, introduced by Budish (2011), is envy-freeness up to one good (EF1), which requires that an agent’s envy towards another bundle can be eliminated by removing some good from the envied bundle. We will present a generalized definition for EF1 that have only been considered in the context of good allocation: the envy can diminish by removing either one “good” from the other’s bundle or one “chore” from their own bundle.

Definition 1 (Ef1)

An allocation is envy-free up to one item (EF1) if for all , either does not envy , or there is an item such that .

Obviously, envy-freeness implies EF1. Conitzer et al. (2017) introduced a novel relaxation of proportionality, which they called PROP1. In the context of good allocation, this fairness relaxation is a weakening of both EF1 and proportionality, requiring that each agent gets her proportional fair share if she obtains one additional good from the others’ bundles. Now we will extend this definition to our setting: under our definition, each agent receives her proportional fair share by obtaining an additional good or removing some chore from her bundle.

Definition 2 (Prop1)

An allocation satisfies proportionality up to one item (PROP1) if for each agent ,

  • ; or

  • for some ; or

  • for some .

It can be easily verified that EF1 implies PROP1.

Proposition 2

An EF1 complete allocation satisfies PROP1.

Proof

Suppose satisfies EF1. Then if gets bonus value by removing getting some good or some chore where , her updated utility is such that for any agent . This would imply that , which implies that . Hence PROP1 is satisfied.

Figure 1 illustrates the relations between fairness concepts introduced above.

EF

PROP

PROP1

EF1
Figure 1: Relations between fairness concepts

Besides fairness, we will also consider an efficiency criterion. The most commonly used efficiency concept is Pareto-optimality. Given an allocation , another allocation is a Pareto-improvement of if for all and for some . We say that an allocation is Pareto-optimal (PO) if there is no allocation that is a Pareto-improvement of .

3 Finding EF1 Allocation

Double Round Robin Algorithm In this section, we focus on EF1, a very permissive fairness concept that admits a polynomial-time algorithm in the case of good allocation. For instance, consider a round robin rule in which agents take turns, and choose their most preferred unallocated item. The round robin rule finds an EF1 allocation if all the items are goods (see e.g., Caragiannis et al. (2016)). By a very similar argument, it can be shown that the algorithm also finds an EF1 allocation if all the items are chores. However, we will show that the round robin rule already fails to find an EF1 allocation if we have some items that are goods and others that are chores.

Proposition 3

The round robin rule does not satisfy EF1.

Proof

Suppose there are two agents and four items with identical utilities described below.

Alice, Bob: 2 -3 -3 -3

Consider the order, in which Alice chooses the only good and then the remaining chores of equal value are allocated accordingly. In that case, Alice gets one a high value good and one chore, whereas Bob gets two chores. So even if one item is removed from the bundles of Alice or Bob, Bob will still remain envious.

Nevertheless, a careful adaptation of the round robin method to our setting, which we call the double round robin algorithm, constructs an EF1 allocation. In essence, the algorithm will apply the round robin method twice: clockwise and anticlockwise. In the first phase, the round-robin algorithm allocates to agents chores, i.e., the items for which each player has non-positive utility, while in the second phase, the reversed round-robin algorithm allocates to agents the remaining goods, in the opposite order starting with the agent who is worst off in the first phase. Intuitively each agent may envy agent who comes earlier than her at the end of one phase, but does not envy with respect to the items allocated in the other round; hence the envy of towards can be bounded up to one item. We formalize the idea in Algorithm 1; see Figure 2 for an illustration.

0:  An instance
0:  An allocation
1:  Partition into , . Suppose for some integer and .
2:  Create dummy chores for which each agent has utility , and add them to . (Hence .)
3:  Let the agents come in a robin robin sequence and pick their most preferred item in until all items in are allocated.
4:  Let the agents come in a robin robin sequence and pick their most preferred item in until all items in are allocated. If an agent has no available item which gives her strictly positive utility, she does not get a real item but pretends to pick a dummy one for which she has utility .
5:  Remove the dummy items from the current allocation and return the resulting allocation .
Algorithm 1 Double Round Robin Algorithm

Figure 2: Illustration of Double Round Robin Algorithm. The dotted line corresponds to the picking order when allocating chores. The thick line corresponds to the picking order when allocating goods. The solid black circle indicates the agent who starts with the picking. For the dotted (chores) round, agent is the first agent to pick. For the solid (goods) round, agent is the first agent to pick.

In the following, for an allocation and a bundle , we say that envies with respect to if .

Theorem 3.1

The double round robin algorithm returns an EF1 complete allocation in time.

Proof

We note that the algorithm ensures that all agents receive the same number of chores, by introducing virtual chores. Now let be the output of Algorithm 1. To see that satisfies EF1, consider any pair of two agents and where . We will show that by removing one item, these agents do not envy each other.

First, consider ’s envy for . We first observe that for the -th item in allocated to is weakly preferred by than the -th item in allocated to . Hence, agent does not envy with respect to . As for the goods allocation, agent may envy agent with respect to , which implies that picks at least one more item from . But if the first item picked by from is removed from ’s bundle, then the envy will diminish, i.e., does not envy with respect to . The reason is that for each item in picked by there is a corresponding item picked by before ’s turn that is at least as preferred by . Thus .

Second, consider ’s envy for . Similarly to the above, agent does not envy agent with respect to because he takes the first pick among and ; that is, for every item in such that , agent picks a corresponding item before that she weakly prefers. As for the items in , let be the last item from chosen by . Then, for each item picked by , there is a corresponding item picked by before that weakly prefers to , which implies does not envy with respect to . Thus .

In either case, agents do not envy each other up to one item. We conclude that is EF1 and so does the final allocation as removing dummy items does not affect the utilities of each agent. It remains to analyze the running time of Algorithm 1. Line 1 requires time as each item needs to be examined by all agents. Lines 3 and 4 require time as there are at most iterations, and for each iteration, each agent considers at most candidates. Thus, the total running time can be bounded by , which completes the proof.∎

Generalized Envy Graph Algorithm Algorithm 1 is designed for additive utilities. We construct another algorithm (Algorithm 2) that finds an EF1 allocation for more general class of doubly monotonic utilities. In these utility functions, each agent partitions the items into desirable and undesirable. The value for bundles of items can be arbitrary but the with restriction that adding an item desirable for an agent cannot decrease her utility and adding an item undesirable for an agent cannot increase her utility. Formally speaking partitions the items into sets and . Any agent ’s utility function is monotonic if for any item and for any bundle of items , if and if .

The algorithm is based on a generalization of an algorithm presented by Lipton et al. (2004) for finding an EF1 allocation for goods. For an allocation , the envy-graph is a directed graph where the vertices is given by the set of agents , and there is an arc from to if and only if envies . For each directed cycle of the envy graph where envies for each and , we may implement an exchange over the cycle, and define the resulting allocation as follows:

0:  An instance
0:  An allocation
1:  Initialize allocation for all
2:  for  do
3:     Set
4:     if  then
5:        Choose an agent with no incoming edge in the graph induced by
6:     else
7:        Choose an agent with no outgoing edge in
8:     end if
9:     Update
10:     while  contains a directed cycle  do
11:        Update
12:     end while
13:  end for
Algorithm 2 Generalized Envy Graph Algorithm
Theorem 3.2

For doubly monotone utilities, the generalized envy-graph algorithm finds an EF1 complete allocation in .

Proof

We will prove by induction that each time a new item is allocated and a while loop is executed, the envy-graph is acyclic and the allocation is EF1. The base case clearly holds since the initial allocation corresponds to the null allocation.

Suppose that items have been allocated and we want to allocate the -th item . If , then let be the envy graph induced by . Since by the induction hypothesis, the envy-graph is acyclic, which means that is acyclic as well. Hence at least one agent has no incoming arc towards in and the algorithm can give item . Since no agent envied agent before, even if some agent now envies agent , the allocation satisfies EF1. If , then we know that all the agents have negative utility for item . Since by the induction hypothesis, the envy graph is acyclic, and thus at least one agent has no out-degree, which follows that we can give item . Since envied no one before, even if envies other agents now, the allocation satisfies EF1.

We now focus on the while loop in the algorithm whereby envy cycles are removed by exchanging allocations along the cycle. After exchanging bundles over cycle , we observe that the agents in the cycle improve their utility and the envy towards each agent in is still bounded up to one good as the set of bundles does not change. Hence, the resulting allocation still satisfies EF1. Further, by removing one cycle, we note that each agent in the cycle has her out-degree decreased by one. Furthermore no agent outside the cycle has her outdegree changed. Hence, after a linear number of cycles removed, the graph has no more envy-cycle and hence is acyclic.

Similarly to (Lipton et al., 2004), the running time of the algorithm can be bounded by . ∎

4 Finding EF1 and PO allocation

We move on the the next question as to whether fairness is achievable together with efficiency. In the context of goods allocation where agents have non-negative additive utilities, Caragiannis et al. (2016) proved that an outcome that maximizes the Nash welfare (i.e., the product of utilities) satisfies EF1 and Pareto-optimality simultaneously. The question regarding whether a Pareto-optimal and EF1 allocation exists for chores is unresolved. If one starts from an EF1 allocation and finds Pareto improvements, one runs into two challenges: first, Pareto improvements may not necessarily preserve EF1; second, finding Pareto improvements is NP-hard (Aziz et al., 2016; de Keijzer et al., 2009). Even if we ignore the second challenge, the question regarding the existence of a Pareto-optimal and EF1 allocation for chores is open.

Next we show that the problem of finding an EF1 and Pareto-optimal allocation is completely resolved for the restricted but important case of two agents. Our algorithm for the problem can be viewed as a discrete version of the well-known Adjusted Winner (AW) rule (Brams and Taylor, 1996a, b). Just like AW, our algorithm is Pareto-optimal and EF1. In contrast to AW that is designed for goods, our algorithm can handle both goods and chores.

Theorem 4.1

For two agents, a Pareto-optimal and EF1 complete allocation always exists and can be computed in polynomial time.

Proof

The algorithm begins by giving each subjective item to the agent who considers it as a good; that is, for each item allocate to agent if and where . So, in the following, let us assume that there is no item for which each agent has utility . Also we assume that we have objective items only, i.e., for each item , either is a good ( for each ); or is a chore ( for each ).

Now we call one of the two agents winner (denoted by ) and another loser (denoted by ). We will allocate each item as follows:

  1. Initially, all goods are allocated to the winner and all chores to the loser.

  2. We sort the items in terms of (monotone non-increasing order), and consider reallocation of the items according to the ordering (from the left-most to the right-most item).

  3. When considering a good, we move it from the winner to the loser. When considering a chore, we move it from the loser to the winner. We stop when we find an EF1 allocation from the point of view of the loser. Note that the loser is envious up to one item of the winner.

We will first prove that at any point of the algorithm, the allocation is Pareto-optimal, and so is the final allocation . Assume towards a contradiction that the allocation is Pareto-dominated by the allocation . For each with , we write

  • is the set of goods allocated to at both and ;

  • is the set of chores allocated to at both and ;

  • is the set of goods allocated to at and allocated to at ;

  • is the set of chores allocated to at and allocated to at .

Without loss of generality, we assume that, in , the winner has utility which is at least as high as in , while the loser is strictly better off. Taking into account that the bundles of goods and and the bundles of chores and are allocated to the same agent in both allocations, this means that

(1)
(2)

The crucial observation now is that the algorithm considered all items in and before the items in and in the ordering (this is why the allocation of the items in the first two bundles changes while the allocation of the items in the last two bundles does not). Let be such that

This definition implies the inequalities,

which, together with inequality (2), yields

a contradiction. The last inequality follows by (1) and by the fact that is non-negative.

Now observe that at the final allocation at most one agent envies the other: if the loser still envies the winner and the winner also envies the loser, then exchanging the bundles would result in a Pareto improvement, a contradiction. Thus, is EF1 when the loser envies the winner at the final allocation . Consider when at the loser does not envy the winner but the winner envies the loser. Let be the previous allocation just before the final transfer, and and . Observe that by construction the loser envies the winner more than one item at , which implies . Suppose towards a contradiction that the winner envies the loser more than one item at , which implies . If is the last good that has been moved from the winner to the loser, then allocating to the loser and to the winner would be a Pareto-improvement of , a contradiction. Similarly, if is the last chore that has been moved from the loser to the winner and the winner, then allocating to the loser and to the winner would be a Pareto-improvement of , a contradiction. Hence, the winner envies the loser up to one item and hence is EF1. ∎

The example below illustrates our discrete adaptation of AW.

Example 1 (Example of the generalized AW)

Consider two agents, Alice and Bob, and five items with the following additive utilities where the gray circles correspond to goods and the white circles correspond to chores.

Alice (winner) : 1 -1 2 1 -2 -4 -6
Bob (loser) : 4 -3 6 2 -2 -2 -2
: 4 3 3 2 1 1/2 1/3

The generalized AW initially allocates the goods to Alice and the chores to Bob. Then, it transfers the first good from Alice to Bob and moves the second chore from Bob to Alice. After moving the third good from Alice to Bob, Bob stops being envious up to one item. Hence the final allocation gives the items and to Alice and the rest to Bob.

A natural question is whether PO and EF1 allocation exists for three players with general additive utilities. We leave this as an interesting open question.

We also note that Pareto-optimality by itself is easy to achieve. We take a permutation of agents and apply a variant of ‘serial dictatorship’. The first agents takes all the items for which she has strictly positive utility for. Each subsequent agent does the same for remaining items. If all agents have been exhausted and there are some items remaining, then the last agents takes all the remaining items.

Proposition 4

A Pareto-optimal allocation can be computed in linear time.

Proof

We take a permutation of agents and apply a variant of ‘serial dictatorship’. The first agents takes all the items for which she has strictly positive utility for. Each subsequent agent does the same for remaining items. If all agents have been exhausted and there are some items remaining, then the last agents takes all the remaining items. The resultant allocation is Pareto-optimal. Any allocation that Pareto dominates it will require that the first agents have the same allocation and therefore the last agent has the same allocation as well. ∎

5 Finding Connected PROP1 Allocation

We have seen that there always exists an EF1 allocation for subjective goods/chores. If we weaken EF1 to PROP1, one can achieve one additional requirement besides fairness, that is, connectivity. Specifically, we will consider a situation when items are placed on a path, and each agent gets a connected bundle of the path. Finding a connected set of items is important in many scenarios. For example, the items can a set of rooms in a corridor and the agents could be research groups where each research group wants to get adjacent rooms (see e.g., (Bouveret et al., 2017; Biló et al., 2018)).

We will show that a connected PROP1 allocation exists and can be found efficiently.111Related questions regarding connected EF1 allocations of goods are considered in the recent paper by Biló et al. (2018). Without loss of generality, we assume that the path is given by a sequence of items . We first prove a result for the case of the cake cutting setting that is of independent interest. In the following, a mixed cake is the interval . Each agent has a value density function , which maps a subinterval of the cake to a real value, where has uniform utility for the interval for each . An allocation of a mixed cake assigns each agent a disjoint sub-interval of the cake where the union of the intervals equals the entire cake ; it satisfies proportionality if each agent gets an interval of value at least the proportional fair share .

Theorem 5.1

A contiguous proportional allocation of a mixed cake exists and can be computed in polynomial time.

Proof

Let be the set of agents with strictly positive total value for . Now we combine the moving-knife algorithms for goods and chores.

Idea: First, if there is an agent who has positive proportional fair share, i.e., , we apply the moving-knife algorithm only to the agents in . Our algorithm moves a knife from left to right, and agents shout whenever the left part of the cake has a value of exactly the proportional fair share. The first agent who shouts is allocated to the left bundle, and the algorithm recurs on the remaining instance. Second, if no agent has positive proportional fair share, our algorithm moves a knife from right to left, and agents shout whenever the left part of the cake has value exactly proportional fair share. Again, the first agent who shouts is allocated to the left bundle, and the algorithm recurs on the remaining instance. Algorithm 3 formalizes the idea.

0:  A sub-interval , agent set , utility functions for each
0:  An allocation of a mixed cake to
1:  Initialize for each .
2:  Set .
3:  if  then
4:     if  then
5:        Allocate to the unique agent in .
6:     else
7:        Let be the minimum point where for .
8:        Find agent with minimum among all agents in .
9:        return   where and
10:     end if
11:  else
12:     Let be the maximum point where for .
13:     Find agent with maximum among all agents in .
14:     return   where and
15:  end if
Algorithm 3 Generalized Moving-knife Algorithm

Correctness: We will prove by induction on that the allocation of a mixed cake produced by satisfies the following:

  • if , then each agent in receives an interval of value at least proportional fair share and each agent not in receives an empty piece; and

  • if , then each agent receives an interval of value at least proportional fair share.

The claim is clearly true when . Suppose that returns a proportional allocation of a mixed cake with desired properties when ; we will prove it for .

Suppose that some agent has positive proportional fair share, i.e., . If , the claim is trivial; thus assume otherwise. Clearly, agent receives an interval of value at least the proportional fair share. Further, all other agents in have value at most the proportional fair share for the left piece . Indeed, if there is an agent whose value for the left piece is greater than the proportional fair share, then would have shouted when the knife reaches before by the continuity of , and , contradicting the minimality of . Thus, the remaining agents in have at least value for the rest of the cake ; hence, by the induction hypothesis each agent in gets an interval of value at least proportional fair share, and the rest of the agents gets an empty piece.

Suppose that no agent has positive proportional fair share. Again, if there is an agent whose value for the left piece is greater than the proportional fair share, then would have shouted when the knife reaches before by the continuity of and , contradicting the maximality of . Thus all the remaining agents have have at least value for the rest of the cake , and hence by the induction hypothesis each agent gets an interval of value at least proportional fair share.

The theorem stated above also applies to a general cake-cutting model in which information about agent’s utility function over an interval can be inferred by a series of queries. We note that a contiguous envy-free allocation of a mixed cake is known to exist only when the number of agents is four or a prime number (Segal-Halevi, 2018; Meunier and Zerbib, 2018). Next, we show how a fractional proportional allocation can be used to achieve a contiguous PROP1 division of indivisible items.

Theorem 5.2

A connected PROP1 allocation of a path always exists and can be computed in polynomial time.

Proof

We know that a fractional contiguous and proportional allocation always exists from Theorem 5.1. In such an allocation we will not change the allocation of agents who get an empty allocation. As for the rest of the agents we do as follows.

Take any contiguous proportional fractional division of a path. From left to right, we allocate the items on the boundary according to the left-agents preferences. Specifically, we assume without loss of generality that agents , receive the 1st, 2nd, …, and -th bundles. Suppose that an item is divided between two agents and . Then we do the following:

  1. If two agents disagree on the sign of , we give the item to the agent who has positive value for it.

  2. If two agents agree on the sign of , we allocate the item in such a way that:

    • the left-agent takes if the value of is positive.

    • the right-agent takes if the value of is negative.

The resulting integral allocation is PROP1. Clearly, the bundles for the end agents and satisfy PROP1. Also, the bundles for the middle agents satisfy PROP1 since such an agent gets value by either receiving the item next to its bundle or deleting the left-most item of his bundle. ∎

6 Discussion

In this paper, we formally studied fair allocation when the items are a combination of subjective goods and chores. Our work paves the way for detailed examination of allocation of goods/chores, and opens up an interesting line of research, with many problems left open to explore. In particular, there are further fairness concepts that could be studied from both existence and complexity issues, most notably envy-freeness up to the least valued item (EFX) (Caragiannis et al., 2016). In our setting, one can define an allocation to be EFX if for any pair of agents , the following two hold:

  1. s.t. : ; and

  2. s.t. : .

That is, ’s envy towards can be eliminated by either removing ’s least valuable good from ’s bundle or removing ’s favorite chore from ’s bundle. Caragiannis et al. (2016) mentioned the following ‘enigmatic’ problem: does an EFX allocation exist for goods? It would be intriguing to investigate the same question for subjective or objective goods/chores.

We also note that while the relationship between Pareto-optimality and most of fairness notions is still unclear, Conitzer et al. (2017) proposed a fairness concept called Round Robin Share that can be achieved together with Pareto-optimality. In our context, RRS can be formalized as follows. Given an instance , consider the round robin sequence in which all agents have the same utilities as agent . In that case, the minimum utility achieved by any of the agents is RRS. An allocation satisfies RRS if each agent gets utility at least RRS. It would be then very natural to ask what is the computational complexity of finding an allocation satisfying both properties.

Finally, recent works of Bouveret et al. (2017) and Biló et al. (2018) showed that a connected allocation satisfying several fairness notions, such as MMS and EF1, is guaranteed to exist for some restricted domains. Although these existence results crucially rely on the fact that the agents have monotonic valuations, it remains open whether similar results can be obtained in fair division of indivisible goods and bads.

References

  • Amanatidis et al. [2015] G. Amanatidis, E. Markakis, A. Nikzad, and A. Saberi. Approximation algorithms for computing maximin share allocations. In Proceedings of the 35th International Colloquium on Automata, Languages, and Programming (ICALP), pages 39–51, 2015.
  • Aziz [2016] H. Aziz. Computational social choice: Some current and new directions. In

    Proceedings of the 25th International Joint Conference on Artificial Intelligence (IJCAI)

    , pages 4054–4057, 2016.
  • Aziz et al. [2015] H. Aziz, S. Gaspers, S. Mackenzie, and T. Walsh. Fair assignment of indivisible objects under ordinal preferences. Artificial Intelligence, 227:71–92, 2015.
  • Aziz et al. [2016] H. Aziz, P. Biro, J. Lang, J. Lesca, and J. Monnot. Optimal reallocation under additive and ordinal preferences. In Proceedings of the 15th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 402–410, 2016.
  • Aziz et al. [2017] H. Aziz, G. Rauchecker, G. Schryen, and T. Walsh. Algorithms for max-min share fair allocation of indivisible chores. In Proceedings of the 31st AAAI Conference on Artificial Intelligence (AAAI), pages 335–341, 2017.
  • Barman and Murthy [2017] S. Barman and S. Kumar Krishna Murthy. Approximation algorithms for maximin fair division. In Proceedings of the 18th ACM Conference on Economics and Computation (ACM-EC), pages 647–664, 2017.
  • Barman et al. [2018] S. Barman, S. Kumar Krishna Murthy, and R. Vaish. Finding fair and efficient allocations. In Proceedings of the 19th ACM Conference on Economics and Computation (ACM-EC). ACM Press, 2018.
  • Biló et al. [2018] V. Biló, I. Caragiannis, M. Flammini, A. Igarashi, G. Monaco, D. Peters, C. Vinci, and W. S. Zwicker. Almost envy-free allocations with connected bundles. CoRR, abs/1808.09406, 2018.
  • Bogomolnaia et al. [2016] A. Bogomolnaia, H. Moulin, F. Sandomirskyi, and E. Yanovskaya. Dividing goods and bads under additive utilities. CoRR, abs/1610.03745, 2016.
  • Bogomolnaia et al. [2017] A. Bogomolnaia, H. Moulin, F. Sandomirskyi, and E. Yanovskaya. Competitive division of a mixed manna. CoRR, abs/1702.00616, 2017.
  • Bouveret and Lemaître [2016] S. Bouveret and M. Lemaître. Characterizing conflicts in fair division of indivisible goods using a scale of criteria. Autonomous Agents and Multi-Agent Systems, 30(2):259–290, 2016.
  • Bouveret et al. [2016] S. Bouveret, Y. Chevaleyre, and N. Maudet. Fair allocation of indivisible goods. In F. Brandt, V. Conitzer, U. Endriss, J. Lang, and A. D. Procaccia, editors, Handbook of Computational Social Choice, chapter 12. Cambridge University Press, 2016.
  • Bouveret et al. [2017] S. Bouveret, K. Cechlárová, E. Elkind, A. Igarashi, and D. Peters. Fair division of a graph. In Proceedings of the Twenty-Sixth International Joint Conference on Artificial Intelligence, IJCAI 2017, Melbourne, Australia, August 19-25, 2017, pages 135–141, 2017.
  • Brams and Taylor [1996a] S. J. Brams and A. D. Taylor. Fair division: From cake-cutting to dispute resolution. Cambridge University Press, 1996a.
  • Brams and Taylor [1996b] S. J. Brams and A. D. Taylor. A procedure for divorce settlements. Issue Mediation Quarterly Mediation Quarterly, 13(3):191–205, 1996b.
  • Budish [2011] E. Budish. The combinatorial assignment problem: Approximate competitive equilibrium from equal incomes. Journal of Political Economy, 119(6):1061–1103, 2011.
  • Caragiannis et al. [2012] I. Caragiannis, C. Kaklamanis, P. Kanellopoulos, and M. Kyropoulou. The efficiency of fair division. Theory of Computing Systems, 50(4):589–610, 2012.
  • Caragiannis et al. [2016] I. Caragiannis, D. Kurokawa, H. Moulin, A. D. Procaccia, N. Shah, and J. Wang. The unreasonable fairness of maximum Nash welfare. In Proceedings of the 17th ACM Conference on Economics and Computation (ACM-EC), pages 305–322. ACM Press, 2016.
  • Conitzer et al. [2017] V. Conitzer, R. Freeman, and N. Shah. Fair public decision making. In Proceedings of the 18th ACM Conference on Economics and Computation (ACM-EC), pages 629–646. ACM Press, 2017.
  • de Keijzer et al. [2009] B. de Keijzer, S. Bouveret, T. Klos, and Y. Zhang. On the complexity of efficiency and envy-freeness in fair division of indivisible goods with additive preferences. In Proceedings of the 1st International Conference on Algorithmic Decision Theory, pages 98–110, 2009.
  • Ghodsi et al. [2018] M. Ghodsi, M. HajiAghayi, M. Seddighin, S. Seddighin, and H. Yami. Fair allocation of indivisible goods: Improvements and generalizations. In Proceedings of the 19th ACM Conference on Economics and Computation (ACM-EC). ACM Press, 2018.
  • Lipton et al. [2004] R. J. Lipton, E. Markakis, E. Mossel, and A. Saberi. On approximately fair allocations of indivisible goods. In Proceedings of the 5th ACM Conference on Electronic Commerce (ACM-EC), pages 125–131. ACM Press, 2004.
  • Meunier and Zerbib [2018] F. Meunier and S. Zerbib. Envy-free divisions of a partially burnt cake. CoRR, abs/1804.00449, 2018.
  • Procaccia and Wang [2014] A. D. Procaccia and J. Wang. Fair enough: Guaranteeing approximate maximin shares. In Proceedings of the 15th ACM Conference on Economics and Computation (ACM-EC), pages 675–692. ACM Press, 2014.
  • Segal-Halevi [2018] Erel Segal-Halevi. Fairly dividing a cake after some parts were burnt in the oven. In Proceedings of the 17th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 1276–1284, 2018. Extended version available as arXiv:1704.00726v5 [math.CO].