An Improved Approximation Algorithm for Maximin Shares

02/28/2019 ∙ by Jugal Garg, et al. ∙ 0

We study the problem of fair allocation of m indivisible items among n agents with additive valuations using the popular notion of maximin share as our measure of fairness. The maximin share (MMS) of an agent is the maximum she can guarantee herself if she is allowed to choose a partition of items into n bundles (one for each agent), with the condition that all other agents get to choose a bundle before her. An MMS allocation provides each agent a bundle worth at least her maximin share. While it is known that such an allocation need not exist, a series of remarkable work provided 2/3 approximation algorithms in which each agent receives a bundle worth at least 2/3 times her maximin share. Recently, in a groundbreaking work, Ghodsi et al. showed the existence of 3/4 MMS allocation and a PTAS to find a 3/4-ϵ MMS allocation. Most of the previous work utilize intricate algorithms and require agents' approximate MMS values, which are computationally expensive to obtain. We present a simple algorithm that obtains a 3/4 MMS allocation and runs in Õ(n^5m) time. The idea is to start with a trivial upper bound on the MMS values based on the average and greedily assign high-value items to agents. Then, try to satisfy the remaining agents with remaining items using tentative assignment and bag-filling procedures. If the MMS upper bounds are tight enough, then these procedures are guaranteed to succeed. Otherwise, we update it for a certain agent and run the procedures again. We show that the bounds need to be updated at most O(n^3) times.

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

We study the problem of allocating indivisible items among agents with additive valuations in a fair manner. Fair division problems have been subject of intense study since the seminal work of Steinhaus (Steinhaus, 1948) (1949) where he introduced the cake-cutting problem for agents: Given a heterogeneous (divisible) cake and a set of agents with different valuation functions, the problem is to find a fair allocation. The two most well-studied notions of fairness are: 1) Envy-freeness, introduced by Foley (Foley, 1967), where each agent prefers her own share of cake over any other agents’ share, and 2) Proportionality, introduced by Steinhaus (Steinhaus, 1948), where each agent receives a share that is worth at least of her value for the entire cake.

In the case of indivisible items, however, no algorithm can provide either envy-freeness or proportionality, e.g., consider allocating a single item among agents. This motivates the need for an alternate concept of fairness. Recently, Budish (Budish, 2011) introduced an intriguing option called maximin share, which has attracted a lot of attention (Procaccia and Wang, 2014; Kurokawa et al., 2016; Ghodsi et al., 2018; Garg et al., 2018; Kurokawa et al., 2018; Barman and Krishna Murthy, 2017; Farhadi et al., 2019; Amanatidis et al., 2017). The idea is a straightforward generalization of the popular cut and choose protocol in the cake cutting problem and a natural relaxation of proportionality. Suppose we ask an agent to partition the items into bundles (one for each agent), with the condition that other agents get to choose a bundle before her. In the worst case, receives the least preferred bundle. Clearly, in such a situation, the agent will choose a partition that maximizes the value of her least preferred bundle. This maximum possible value is called ’s maximin share (MMS) value. In fact, when all agents have the same valuations, cannot guarantee more than the MMS value. We note that computing MMS value of an agent is an NP-hard problem111Observe that the partition problem reduces to the MMS value problem with ., but a polynomial time approximation scheme (PTAS) exists (Woeginger, 1997).

Each agent’s MMS value is a specific objective that gives her an intuitive local measure of the fairness of an allocation. This raises a natural question: Is there an allocation where each agent receives a bundle that is worth at least her MMS value? An allocation satisfying this property is said to be maximin share allocation (MMS allocation), and if it exists, it provides strong fairness guarantees to each individual agent. Bouveret and Lemaître (Bouveret and Lemaître, 2016a) showed that an MMS allocation always exists in some restricted cases, e.g., when there are only two agents or if agents’ valuations for items are either 0 or 1, but left the general case as an open problem.

Procaccia and Wang (Procaccia and Wang, 2014)222Recipient of the best student paper award at ACM EC’14 obtained the surprising result that MMS allocation might not exist, by means of a clever example. Furthermore, they showed that a 2/3 MMS allocation always exists, i.e., an allocation where each agent receives a bundle worth at least 2/3 of their MMS value, and they provided a polynomial time algorithm to find a 2/3 MMS allocation when the number of agents is constant. For the special case of four agents, their algorithm finds a MMS allocation. Amanatidis et al. (Amanatidis et al., 2017) improved this result by addressing the requirement for a constant number of agents, obtaining a PTAS which finds a MMS allocation for an arbitrary number of agents; see (Kurokawa et al., 2018) for an alternate proof. (Amanatidis et al., 2017) also showed that a MMS allocation always exists when there are three agents. This factor was later improved to in (Gourvès and Monnot, 2019).

Taking a different approach, Barman and Murthy (Barman and Krishna Murthy, 2017) obtained a greedy algorithm to find a 2/3 MMS allocation. While their algorithm is fairly simple, the analysis is not. More recently, Garg et al. (Garg et al., 2018) obtained a simple algorithm to find a 2/3 MMS allocation that also has a simple analysis.

In a groundbreaking work, Ghodsi et al. (Ghodsi et al., 2018) improved these results by showing the existence of a 3/4 MMS allocation and a PTAS to find a MMS allocation. We note that the technique and analysis of their algorithm are quite involved.

Our Results and Techniques. We propose a simple algorithm to find a -MMS allocation by utilizing key ideas and insights from previous works. The running time of the entire procedure is . Unlike (Ghodsi et al., 2018) and other previous works, our algorithm does not need to compute agents’ approximate MMS values, which is computationally expensive. This not only improves the previous best approximation factor by but also makes the algorithm likely to be more efficient in practice since the dependency on the number of items is just about linear.

For each agent, we first use the average value, that is the value of all items divided by the number of agents, as an upper bound of her MMS value, and then we greedily assign one, two, and three high-value items to an agent who values them at least times her MMS value. After each assignment, we update the MMS value based on the new average. We call these Fixed Assignments because these assignments do not decrease the MMS values of remaining agents, so we do not need to reconsider them. This reduces the number of high-value items to at most twice the number of remaining agents. We note that the allocation of high-value items is the most challenging part of the problem, also observed by (Ghodsi et al., 2018; Garg et al., 2018). In fact, (Ghodsi et al., 2018) spends a major part of the paper in explaining the allocation of high-value items.

Next, we start tentative assignments, i.e., these are valid only if our current upper bound of the MMS values is tight enough. Then, we initialize a set of bags, one for each remaining agent, and put all high-value items in these bags in a particular way such that each bag has at most two high-value items. If the current upper bound of MMS values is not tight enough for some agents, which we check using the total valuation of low-value items, then we update the MMS value of such an agent and repeat. We show that we do not need to update the MMS upper bounds more than times before we have a good upper bound on all MMS values. Once that happens, then we run a bag filling procedure, which is a generalized version of bag filling used in (Ghodsi et al., 2018) to fill the bags with the low-value items such that each agent gets a bag worth at least times her MMS value.

Further Related Work. Maximin share is a popular notion for the fair allocation of indivisible items among agents. Apart from the work mentioned above, it has been studied for asymmetric agents (i.e., agents with different entitlements) (Farhadi et al., 2019), for group fairness (Barman et al., 2018), beyond additive valuations (Barman and Krishna Murthy, 2017; Ghodsi et al., 2018), with additional constraints (Gourvès and Monnot, 2019), and for agents with externalities (Brânzei et al., 2013; AhmadiPourAnari et al., 2013).

2. Problem Statement

We consider the fair allocation of indivisible items among agents with additive valuations, using the popular notion of maximin share (MMS) as our measure of fairness. That is, is agent ’s value for item , and ’s valuation of any bundle of items is given by . Denote the set of valuation functions, , as .

Let denote an instance of the fair division problem. Let denote a partition of the items into bundles (one for each agent). Agent ’s maximin share is the maximum value she can guarantee herself if she is allowed to choose the partition , on the condition that other agents choose their bundle from the partition before her. Formally, let be the set of all feasible partitions of into bundles. Agent ’s maximin share is:

We say an allocation is MMS if each agent receives a bundle worth at least her maximin share, i.e., . An allocation is approximate MMS (or simply -MMS), for some if .

3. Properties of MMS allocation

In this section, we state a few key properties of maximin shares that our algorithm exploits. We note that these are standard results which appear in (Procaccia and Wang, 2014; Amanatidis et al., 2017; Bouveret and Lemaître, 2016b; Barman and Krishna Murthy, 2017; Garg et al., 2018; Ghodsi et al., 2018). We include proofs for completeness.

3.1. Average and Scale Invariance

Lemma 3.1 (Average upper bounds MMS).

.

Proof.

Suppose for some agent , which means that there exist a partition of into bundles where all bundles have value strictly more than . Therefore, , which is a contradiction. ∎

Lemma 3.2 (Scale Invariance).

Let be an -MMS allocation for instance . For any agent and any , if we create an alternate instance where ’s valuations are scaled by , i.e., , then is still an -MMS allocation for . Further, , where and are for and respectively.

Proof.

For any bundle , we have . Therefore, . Let be the partition chooses to create her . Then, . ∎

Definition 3.3 ().

We call an instance normalized if for all .

3.2. Ordered Instances

We say that an instance is ordered if:

In words, in an ordered instance all agents have the same order of preferences over items. Bouveret and Lemaître (Bouveret and Lemaître, 2016b) showed that the ordered instances are worst case. They provided a reduction from any arbitrary instance to an ordered instance , and showed that if is an MMS allocation for , then one can find an MMS allocation for in polynomial time (see Algorithms 1 and 2). Later, Barman and Murthy (Barman and Krishna Murthy, 2017) generalized this result for approximate MMS allocations. This property is used by (Barman and Krishna Murthy, 2017; Garg et al., 2018) to find a -MMS allocation. Observe that value of an agent in instance and is the same because MMS value neither depends on the order of the items nor on the valuations of the other agents.

Input : Instance
Output : Instance which for all
1 for  to  do
2       for  to  do
3             highest value item of for agent
4      
Algorithm 1 (Barman and Krishna Murthy, 2017) Conversion to an Ordered Instance
Input : Instance , Ordered Instance , -MMS allocation for
Output : -MMS allocation for
1 for  to  do
         // is the agent who has item of in her bundle
         // is ’s favorite unassigned item
2      
Algorithm 2 (Barman and Krishna Murthy, 2017) MMS Allocation for Unordered Instance
Lemma 3.4 ().

(Bouveret and Lemaître, 2016b; Barman and Krishna Murthy, 2017) Given any instance , we can find an ordered instance in polynomial time using Algorithm 1. Furthermore, given an -MMS allocation for the ordered version , using Algorithm 2, we can find -MMS allocation for the original instance in polynomial time.

Proof.

Clearly, items in are sorted by their value and they have the same order for all agents. Also, it takes iterations to obtain . Note that MMS value will remain same in since MMS value does not depend on the order of items or the valuation of other agent. We prove that for all . Consider the round of the Algorithm 2 and consider item from is in . It means that agent is getting her favorite item in but now after round, exactly items are allocated and she will get her favorite item among un-allocated items. Therefore, the item she gets in this round is at least as valuable as the one she was getting in the ordered instance. Therefore, . ∎

Corollary 3.5 ().

Without loss of generality, we can assume agents have the same order of preference over items, i.e.,

3.3. Bag Filling for Low Value Items

Ghodsi et al. (Ghodsi et al., 2018) showed that if and , then we can find a MMS allocation using the bag filling procedure. In this paper, we use bag filling algorithm in a slightly more general way.

Given a , let be the set of high-value items, i.e., every item of is valued at least by some agent, and let be the set of low-value items, i.e., every item of is valued strictly less than by all agents.

Theorem 3.6 ().

Given , an instance , and a partition of high-value items such that , then Algorithm 3 finds an allocation where in polynomial time.

Input : , Instance , and Bags containing all high-value items such that
Output : Allocation where
1 for  = 1 to  do
2       Define while  do
               // pick one low value item arbitrarily
               // add the new to item the bag
3            
        // assign bundle to an agent
4       ;
Algorithm 3 Bag Filling Algorithm for -MMS Allocation
Proof.

Since , we get

If a bundle worth at least for some agent we can assign it to agent (if there are ties we choose an agent arbitrarily). If for all agents we start adding low value items to until someone values it at least and then we can assign the bag to such an agent. Before adding the last item no one value the bag more than and the value of the last item is at most . Therefore, no agent loses more than after removing the bag. Therefore, there will be enough low value items to fill all the bags and satisfy all the agents. ∎

3.4. Reduction

This useful concept is defined in (Ghodsi et al., 2018) and later used in (Garg et al., 2018). Let denote the MMS value of agent when is the set of items that needs to be divided among agents (including ). Recall that for the MMS allocation problem for the fair division instance , we want to partition into bundles such that .

Definition 3.7 (Valid reduction).

We call the act of removing a set of items and an agent a valid reduction if

(1)

Throughout our algorithm in Section 4, we use this property to remove high value items from the instance and get a smaller instance which, according to Definition 3.7, a 3/4 MMS allocation for the smaller instance gives a 3/4 MMS allocation for the original instance.

Update : After each valid reduction with and , we update , , and . Note that this maintains after initial normalization (Definition 3.3 and Lemma 3.1).

4. Algorithm and Analysis

Input : Ordered Instance , i.e.,
Output : 3/4 Approximate Maximin Share Allocation
Normalize Valuations (i.e., scale valuations so that //
Fixed-Assignment  // Algorithm 5
Tentative-Assignment  // Algorithm 6
1 while there exists a Type 2B agent in  do
       the lowest index Type 2B agent in   // Type 2B is defined in Section 4.3
       Undo Tentative-assignments  // Go back to
       Update ’s MMS upper bound  // Theorem 4.20
       Fixed-Assignment  // assignments made are final
2       Tentative-Assignment
Make all tentative assignments final Bag-Filling   // Section 4.4 and Algorithm 3
Algorithm 4 -MMS Allocation

In this section, we describe the algorithm to find a maximin share allocation for a given instance and its analysis. As it is shown in Section 3, we can without loss of generality work with the normalized valuations so that for all agents and assume to be an ordered instance, i.e., . Also, we fix the order of agents in such that at each step of the algorithm if there are more than one agent interested in a set of items we assign the set to the one with the lowest index. We maintain the same order among remaining agents after every valid reduction.

The main algorithm is given in Algorithm 4. Throughout the algorithm, we use and to denote respectively the number of agents and number of items of the current instance.

Algorithm 4 has four main parts.

  1. Fixed Assignment (Algorithm 5 and Section 4.1): Recursively removes high value items using valid reductions (Definition 3.7). After each reduction, we have a new smaller instance, and we do not consider the removed items and agents for the rest of the algorithm.

  2. Tentative Assignment (Algorithm 6 and Section 4.2): After fixed assignments, the number of high-value items (items worth at least to some agent) reduces to at most , and then we tentatively assign items to agents assuming that . We call these assignments tentative because they are valid if the current MMS upper bounds are tight for all agents.

  3. Update Upper Bound (Section 4.3): First, we initialize a set of bags (one for each remaining agent) and fill them with the first items in a certain way, and then using these bags, we check if the current MMS upper bound for some agent needs to be updated. If not, then we finalize the tentative assignments and go to the next part.

  4. Bag Filling (Algorithm 3 and Section 3.3): We start the bag filling procedure for low-value items on top of the bags which are initialized in the previous part.

After each assignment (fixed or tentative) we perform two actions:

  1. Assign: Assign the items that are being removed to the agent with the lowest index who values these items at least 3/4.

  2. Update : Update and by removing the items which are assigned and the agents who are satisfied. Also, update the valuations for the remaining agents (see Section 3.4) so that the new MMS upper bound remains for every agent.

4.1. Fixed Assignment

Input : Ordered Instance (i.e., ), where
Output : Fixed Assignments and Reduced Instance
For any , define   // changes with
  // Bundles that can be assigned
1 while  do
       the lowest index agent in the lowest index bundle in for which Assign to agent   // final assignment
       Update   // see Section 3.4
2      
return
Algorithm 5 Fixed-Assignment

In this part, we allocate high-value items to agents using Algorithm 5. Let (the highest value item for all agents), (the bundle with and highest valued items for all agents), and (the bundle with and highest valued items for all agents). In Algorithm 5, we assign the bundle to the agent for which (if there are many such agents, we choose the one with the lowest index). Then we update (as in Section 3.4) and we repeat this step until no such agent exists. In Lemma 4.1, 4.2, 4.3 we prove that allocating to agent and removing them from and is a valid reduction.

Lemma 4.1 ().

(Ghodsi et al., 2018; Garg et al., 2018). Removing item 1 and agent with is a valid reduction.

Proof.

Clearly, . Removal of one item in the MMS partition of each agent affects exactly one bundle and each of the remaining bundles has value at least MMS. Therefore, MMS value of agent in the reduced instance does not decrease. ∎

Lemma 4.2 ().

(Garg et al., 2018). Removing two items and agent with is a valid reduction.

Proof.

Clearly . In MMS partition of agent , there is a bundle with two items from (pigeonhole principle). Let be a bundle in MMS partition of agent that has two items from . Let us exchange these items with items and in other bundles and distribute any remaining item in among other bundles arbitrarily. Clearly, the value of other bundles does not decrease, and hence the MMS value of the remaining agents after removing and agent will not decrease. ∎

Lemma 4.3 ().

Removing three items and agent with is a valid reduction.

Proof.

Similar to the proof of Lemma 4.2. ∎

Throughout the paper, let , , and .

Corollary 4.4 ().

If there does not exists an for which for then

  1. ,

  2. and ,

  3. .

4.2. Tentative Assignment

Input : Ordered Instance that satisfies Condition 1-3 in Corollary 4.4
Output : Tentative Assignments and Reduced Instance
For any , define   // changes with
  // Bundles that can be assigned on the condition that (see Section 4.1 and 4.2)
1 while  do
       the lowest index agent in the lowest index bundle in for which Assign to agent   // tentative assignment
       Update   // see Section 3.4
2      
return
Algorithm 6 Tentative-Assignment

In this part of the algorithm, we assume that , i.e., the actual MMS value for each agent is equal to her current MMS upper bound, and we allocate some bundles using this assumption. This is unlike Section 4.1, where we did not need the MMS value assumption, so the assignments made in Algorithm 5 were final. In the next step, either this assumption works fine and we move to the bag filling process or we detect that there is an an agent whose MMS value is significantly lower than 1. In the latter case, we update ’s MMS upper bound. Recall that we update the MMS upper bound by updating the valuations so that the new MMS upper bound remains for every agent.

Let and as defined in Section 4.1. For we check whether there exists an with . If such an agent exists then we tentatively assign (the lowest index if there are multiple ’s satisfying the condition) to agent (if there are many such agents we assign to the one with the lowest index) and we tentatively update as we did in Section 4.1. Choosing the lowest index makes sure that when is assigned, then none of satisfies the condition. This is essential in proving that assigning to an agent is a valid reduction in Lemma 4.5.

Note that at the beginning of this part the value of each bundle in for every agent is strictly less than 3/4. However, after removing an agent with , it may later trigger a valid reductions with .

Lemma 4.5 ().

(Ghodsi et al., 2018) If , then assigning to agent with is a valid reduction.

Proof.

From Corollary 4.4, we have and . Suppose , then in MMS partition of an agent , if items and are in the same bundle, then clearly, removing and agent is a valid reduction. For the other case, if and are in two different bundles, then we can make two new bundles, one with and another with all the remaining items of the two bundles. Clearly, the value of the bundle without is at least one, and hence this is a valid reduction. ∎

4.3. Updating MMS Upper Bound

The goal of this section is to update the MMS upper bound for some agent, if needed, before we start the bag-filling process. Recall that is the number of agents in the current instance, and it keeps changing with . Recall that and denote the set of highest valued and items respectively, and . First we initialize bags using the first items as follows.

(2)

Each bag contains one item from and one item from such that from to value of items from decreases and value of items from increases. We divide the agents into two types:

  • Type 1: for all bundles.

  • Type 2: for some bundle(s).

If all agents are in Type 1, then we do not need to update the MMS upper bounds, and we can start bag filling. Otherwise, we need to analyze Type 2 agents more thoroughly.

Definition 4.6 ().

For a Type 2 agent , define

(3)

In words, is the least total value needed to make all bundles in at least 3/4.

Lemma 4.7 ().

For a Type 2 agent , and .

Proof.

By definition, if then is a Type 1 agent. Further, implies , which cannot be true due to Corollary 4.4. ∎

We partition Type 2 agents further into two sub-types as follows:

  1. Type 2A: or

  2. Type 2B: and

If there are no Type 2B agents, then we do not need to update the MMS upper bounds, and we can start bag filling. Otherwise, we will show that MMS value for each Type 2B agent is strictly less than 1, and we find a new upper bound for their MMS values. We begin by showing a few results.

Lemma 4.8 ().

For each Type 2 agent , .

Proof.

From Corollary 4.4, . Since , this implies that there exists a such that . Further, since item is the highest value item for every agent, . ∎

Lemma 4.9 ().

For any , .

Proof.

Each item of has value less than 3/4 and each item of has value less than 3/8 (Corollary 4.4) for any agent. Therefore, for any bundle . ∎

Lemma 4.10 ().

For a Type 2 agent , if , then .

Proof.

The value of item 1 for a Type 2 agent is more than 5/8 (Lemma 4.8) and , hence . ∎

Lemma 4.11 ().

Consider a Type 2 agent and let be her MMS partition of items. If MMS then there exist a bundle such that .

Proof.

If there exists a bundle with exactly one item from , then because value of every item is less than 3/4. For the other case, each bundle has exactly two items from , which implies that one of the bundles, say , has two items from the set . Since , . ∎

Lemma 4.12 ().

For a Type 2 agent with MMS, there exists a MMS partition where no bundle has two items such that .

Proof.

We show that if there are two items with value (for agent ) more than 5/8 in a bundle of MMS partition, then we can construct another MMS partition in which all items with value more than 5/8 are in different bundles. Suppose has two items and with value more than 5/8, then Corollary 4.4 implies that there must exist another bundle for which . If there exists a partition and of items in such that value of each and is at least 3/8, then we can rearrange items in and make two new bundles and . Clearly, the value of each bundle is at least one and each has exactly one item with value more than 5/8.

If no such and exist, then we claim that there exists a partition of into three sets with each value less than 3/8. We can find this partition by making three empty sets and sorting the items in from high to low value and adding them to the bundle with the lowest value one by one. For a contradiction, suppose one of the three sets has value more than 3/8, then the sum of the value of other two sets should be less than 3/8 because otherwise, they make a partition of two with each value more than 3/8. This means that at least one of the sets must have a value less than 3/16. This implies that the value of the other bag before adding the last item must be less than 3/16 and the last item also should value less than 3/16, which is a contradiction. Therefore, there exists a partition , and of such that each value less than 3/8.

According to Lemma 4.11, there exists a bundle such that . Let for some . Observe that cannot be same as and , otherwise we would have made two bundles earlier, each with value at least and exactly one item more than . We make three bags:

The value of each of bag 1 and bag 2 is at most 9/8 and the value of bag 3 is at most 9/8 + . The total value of all items in , and is at least 3+2/8+. We sort the remaining items in decreasing order and add them one by one to a bag with the lowest value. Since the value of the last item added to each bag has a value of at most 1/8 (from Lemma 4.10), each bag has a value of at least 1 and it has at most one item with value more than 5/8. ∎

Next, we show that MMS value for a Type 2B agent is strictly lower than 1, and then we show how to update it. Fix a Type 2B agent . For simplicity, until the end of this section, when we use value of an item or a bundle, we mean their value for agent (unless mentioned otherwise). Let be a MMS partition of agent . For contradiction, assume that . For simplicity, we use instead of and instead of (Definition 4.6).

We manipulate the partition : First, for each with , if and , then we turn and into two new bundles and . We have . Hence, we can assume that for each (Definition 4.6), there exists a . Second, we re-enumerate the bundles in such that

  • be the ones that has an item, say , of value more than 5/8 for agent and ( such bundles),

  • be the ones that has an item, say , of value more than 5/8 for agent and (Observe that there are such bundles, so ),

  • be the ones for which and ,

  • be the remaining bundles (Observe that ).

Definition 4.13 ().

Define where is the highest value item in the set . Observe that .

Lemma 4.14 ().

For any bundle such that , we have .

Proof.

The claim follows from the construction of ’s (2), and the fact that each bundle of has an item with value more than . ∎

Lemma 4.15 ().

If , then for agent , we have

(4)
Proof.

Since , we have (Lemma 4.14). This implies that . ∎

Lemma 4.16 ().

For agent , if , then

(5)

where .

Proof.

In there are exactly items from . If there are at least in then . On the other hand, if there are items in , then it means that there are at least bundles in with exactly one item from . Each of these bundles need more than value of items from to become 1.

Next, if , then all bundles in need at least value of items from to become because the value of each item in the bundles of is at least (follows from Definition 4.13 and the construction of ’s in (2)). If , then all bundles in need at least value of items from to become one because each of the items has value at most (Lemma 4.14). Therefore, in total, there should be at least value of items from in .

Further, in case is large such that the value of is negative, we still need value of items from to make all bundles in one. ∎

Theorem 4.17 ().

For agent , if , then

(6)
Proof.

Using Lemma 4.16 there are two cases for the maximum of and . We prove the claim for each case separately.

Case 1: Suppose , then . Further, (4) implies . Using these, we get